@bonginkan/maria 3.6.3 → 3.6.4

package/dist/cli.cjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 'use strict';
 
-var fs4 = require('fs');
-var path6 = require('path');
+var fs6 = require('fs');
+var path8 = require('path');
 var os2 = require('os');
 var events = require('events');
-var fs6 = require('fs/promises');
+var fs8 = require('fs/promises');
 var Stream = require('stream');
 var util = require('util');
 var buffer = require('buffer');
@@ -15,6 +15,7 @@ var url = require('url');
 var https = require('https');
 var zlib = require('zlib');
 var chalk13 = require('chalk');
+var child_process = require('child_process');
 var readline = require('readline');
 var dotenv = require('dotenv');
 var OpenAI = require('openai');
@@ -50,10 +51,10 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs4__namespace = /*#__PURE__*/_interopNamespace(fs4);
-var path6__namespace = /*#__PURE__*/_interopNamespace(path6);
-var os2__namespace = /*#__PURE__*/_interopNamespace(os2);
 var fs6__namespace = /*#__PURE__*/_interopNamespace(fs6);
+var path8__namespace = /*#__PURE__*/_interopNamespace(path8);
+var os2__namespace = /*#__PURE__*/_interopNamespace(os2);
+var fs8__namespace = /*#__PURE__*/_interopNamespace(fs8);
 var Stream__default = /*#__PURE__*/_interopDefault(Stream);
 var http__default = /*#__PURE__*/_interopDefault(http);
 var https__default = /*#__PURE__*/_interopDefault(https);
@@ -115,8 +116,8 @@ var init_conversation_persistence = __esm({
       autoSaveInterval = null;
       pendingWrites = [];
       constructor(maxHistorySize = 100) {
-        const configDir = path6__namespace.join(os2__namespace.homedir(), ".maria");
-        this.sessionFile = path6__namespace.join(configDir, "conversation-history.json");
+        const configDir = path8__namespace.join(os2__namespace.homedir(), ".maria");
+        this.sessionFile = path8__namespace.join(configDir, "conversation-history.json");
         this.maxHistorySize = maxHistorySize;
         this.ensureConfigDir();
         this.startAutoSave();
@@ -126,8 +127,8 @@ var init_conversation_persistence = __esm({
        */
       async ensureConfigDir() {
         try {
-          const configDir = path6__namespace.dirname(this.sessionFile);
-          await fs4.promises.mkdir(configDir, { recursive: true });
+          const configDir = path8__namespace.dirname(this.sessionFile);
+          await fs6.promises.mkdir(configDir, { recursive: true });
         } catch (error) {
           console.warn("Failed to create config directory:", error);
         }
@@ -137,7 +138,7 @@ var init_conversation_persistence = __esm({
        */
       async loadHistory() {
         try {
-          const data2 = await fs4.promises.readFile(this.sessionFile, "utf-8");
+          const data2 = await fs6.promises.readFile(this.sessionFile, "utf-8");
           const session = JSON.parse(data2);
           const messages = session.messages.map((msg) => ({
             ...msg,
@@ -175,7 +176,7 @@ var init_conversation_persistence = __esm({
               model: messages[messages.length - 1]?.model
             }
           };
-          await fs4.promises.writeFile(this.sessionFile, JSON.stringify(session, null, 2));
+          await fs6.promises.writeFile(this.sessionFile, JSON.stringify(session, null, 2));
         } catch (error) {
           console.warn("Failed to save conversation history:", error);
         }
@@ -185,7 +186,7 @@ var init_conversation_persistence = __esm({
        */
       async clearHistory() {
         try {
-          await fs4.promises.unlink(this.sessionFile);
+          await fs6.promises.unlink(this.sessionFile);
         } catch (innerError) {
         }
         this.pendingWrites = [];
@@ -196,7 +197,7 @@ var init_conversation_persistence = __esm({
       async getStats() {
         try {
           const messages = await this.loadHistory();
-          const stats = await fs4.promises.stat(this.sessionFile);
+          const stats = await fs6.promises.stat(this.sessionFile);
           return {
             totalMessages: messages.length,
             oldestMessage: messages[0]?.timestamp,
@@ -266,7 +267,7 @@ var init_chat_context_service = __esm({
           maxTokens: config2?.maxTokens || 128e3,
           compressionThreshold: config2?.compressionThreshold || 0.8,
           summaryTokenLimit: config2?.summaryTokenLimit || 2e3,
-          persistPath: config2?.persistPath || path6__namespace.join(process.env["HOME"] || "", ".maria", "context")
+          persistPath: config2?.persistPath || path8__namespace.join(process.env["HOME"] || "", ".maria", "context")
         };
         this.sessionId = this.generateSessionId();
       }
@@ -385,8 +386,8 @@ var init_chat_context_service = __esm({
       async persistSession() {
         if (!this.config.persistPath) return;
         try {
-          await fs6__namespace.mkdir(this.config.persistPath, { recursive: true });
-          const sessionFile = path6__namespace.join(
+          await fs8__namespace.mkdir(this.config.persistPath, { recursive: true });
+          const sessionFile = path8__namespace.join(
             this.config.persistPath,
             `${this.sessionId}.json`
           );
@@ -398,7 +399,7 @@ var init_chat_context_service = __esm({
             fullHistory: this.fullHistory,
             compressionCount: this.compressionCount
           };
-          await fs6__namespace.writeFile(sessionFile, JSON.stringify(sessionData, null, 2));
+          await fs8__namespace.writeFile(sessionFile, JSON.stringify(sessionData, null, 2));
           this.emit("session-persisted", sessionFile);
         } catch (error) {
           this.emit(
@@ -1401,7 +1402,7 @@ var require_ponyfill_es2018 = __commonJS({
         return new originalPromise(executor);
       }
       function promiseResolvedWith(value) {
-        return newPromise((resolve2) => resolve2(value));
+        return newPromise((resolve4) => resolve4(value));
       }
       function promiseRejectedWith(reason) {
         return originalPromiseReject(reason);
@@ -1571,8 +1572,8 @@ var require_ponyfill_es2018 = __commonJS({
         return new TypeError("Cannot " + name2 + " a stream using a released reader");
       }
       function defaultReaderClosedPromiseInitialize(reader2) {
-        reader2._closedPromise = newPromise((resolve2, reject) => {
-          reader2._closedPromise_resolve = resolve2;
+        reader2._closedPromise = newPromise((resolve4, reject) => {
+          reader2._closedPromise_resolve = resolve4;
           reader2._closedPromise_reject = reject;
         });
       }
@@ -1623,11 +1624,11 @@ var require_ponyfill_es2018 = __commonJS({
           throw new TypeError(`${context2} is not a function.`);
         }
       }
-      function isObject(x2) {
+      function isObject2(x2) {
         return typeof x2 === "object" && x2 !== null || typeof x2 === "function";
       }
       function assertObject(x2, context2) {
-        if (!isObject(x2)) {
+        if (!isObject2(x2)) {
           throw new TypeError(`${context2} is not an object.`);
         }
       }
@@ -1746,8 +1747,8 @@ var require_ponyfill_es2018 = __commonJS({
           }
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve2, reject) => {
-            resolvePromise = resolve2;
+          const promise = newPromise((resolve4, reject) => {
+            resolvePromise = resolve4;
             rejectPromise = reject;
           });
           const readRequest = {
@@ -1852,8 +1853,8 @@ var require_ponyfill_es2018 = __commonJS({
           const reader2 = this._reader;
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve2, reject) => {
-            resolvePromise = resolve2;
+          const promise = newPromise((resolve4, reject) => {
+            resolvePromise = resolve4;
             rejectPromise = reject;
           });
           const readRequest = {
@@ -2872,8 +2873,8 @@ var require_ponyfill_es2018 = __commonJS({
           }
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve2, reject) => {
-            resolvePromise = resolve2;
+          const promise = newPromise((resolve4, reject) => {
+            resolvePromise = resolve4;
             rejectPromise = reject;
           });
           const readIntoRequest = {
@@ -3185,10 +3186,10 @@ var require_ponyfill_es2018 = __commonJS({
           wasAlreadyErroring = true;
           reason = void 0;
         }
-        const promise = newPromise((resolve2, reject) => {
+        const promise = newPromise((resolve4, reject) => {
           stream._pendingAbortRequest = {
             _promise: void 0,
-            _resolve: resolve2,
+            _resolve: resolve4,
             _reject: reject,
             _reason: reason,
             _wasAlreadyErroring: wasAlreadyErroring
@@ -3205,9 +3206,9 @@ var require_ponyfill_es2018 = __commonJS({
         if (state === "closed" || state === "errored") {
           return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`));
         }
-        const promise = newPromise((resolve2, reject) => {
+        const promise = newPromise((resolve4, reject) => {
           const closeRequest = {
-            _resolve: resolve2,
+            _resolve: resolve4,
             _reject: reject
           };
           stream._closeRequest = closeRequest;
@@ -3220,9 +3221,9 @@ var require_ponyfill_es2018 = __commonJS({
         return promise;
       }
       function WritableStreamAddWriteRequest(stream) {
-        const promise = newPromise((resolve2, reject) => {
+        const promise = newPromise((resolve4, reject) => {
           const writeRequest = {
-            _resolve: resolve2,
+            _resolve: resolve4,
             _reject: reject
           };
           stream._writeRequests.push(writeRequest);
@@ -3838,8 +3839,8 @@ var require_ponyfill_es2018 = __commonJS({
         return new TypeError("Cannot " + name2 + " a stream using a released writer");
       }
       function defaultWriterClosedPromiseInitialize(writer) {
-        writer._closedPromise = newPromise((resolve2, reject) => {
-          writer._closedPromise_resolve = resolve2;
+        writer._closedPromise = newPromise((resolve4, reject) => {
+          writer._closedPromise_resolve = resolve4;
           writer._closedPromise_reject = reject;
           writer._closedPromiseState = "pending";
         });
@@ -3875,8 +3876,8 @@ var require_ponyfill_es2018 = __commonJS({
         writer._closedPromiseState = "resolved";
       }
       function defaultWriterReadyPromiseInitialize(writer) {
-        writer._readyPromise = newPromise((resolve2, reject) => {
-          writer._readyPromise_resolve = resolve2;
+        writer._readyPromise = newPromise((resolve4, reject) => {
+          writer._readyPromise_resolve = resolve4;
           writer._readyPromise_reject = reject;
         });
         writer._readyPromiseState = "pending";
@@ -3963,7 +3964,7 @@ var require_ponyfill_es2018 = __commonJS({
         source._disturbed = true;
         let shuttingDown = false;
         let currentWrite = promiseResolvedWith(void 0);
-        return newPromise((resolve2, reject) => {
+        return newPromise((resolve4, reject) => {
           let abortAlgorithm;
           if (signal !== void 0) {
             abortAlgorithm = () => {
@@ -4108,7 +4109,7 @@ var require_ponyfill_es2018 = __commonJS({
             if (isError) {
               reject(error);
             } else {
-              resolve2(void 0);
+              resolve4(void 0);
             }
             return null;
           }
@@ -4389,8 +4390,8 @@ var require_ponyfill_es2018 = __commonJS({
         let branch1;
         let branch2;
         let resolveCancelPromise;
-        const cancelPromise = newPromise((resolve2) => {
-          resolveCancelPromise = resolve2;
+        const cancelPromise = newPromise((resolve4) => {
+          resolveCancelPromise = resolve4;
         });
         function pullAlgorithm() {
           if (reading) {
@@ -4481,8 +4482,8 @@ var require_ponyfill_es2018 = __commonJS({
         let branch1;
         let branch2;
         let resolveCancelPromise;
-        const cancelPromise = newPromise((resolve2) => {
-          resolveCancelPromise = resolve2;
+        const cancelPromise = newPromise((resolve4) => {
+          resolveCancelPromise = resolve4;
         });
         function forwardReaderError(thisReader) {
           uponRejection(thisReader._closedPromise, (r2) => {
@@ -5262,8 +5263,8 @@ var require_ponyfill_es2018 = __commonJS({
           const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
           const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
           let startPromise_resolve;
-          const startPromise = newPromise((resolve2) => {
-            startPromise_resolve = resolve2;
+          const startPromise = newPromise((resolve4) => {
+            startPromise_resolve = resolve4;
           });
           InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
           SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
@@ -5356,8 +5357,8 @@ var require_ponyfill_es2018 = __commonJS({
         if (stream._backpressureChangePromise !== void 0) {
           stream._backpressureChangePromise_resolve();
         }
-        stream._backpressureChangePromise = newPromise((resolve2) => {
-          stream._backpressureChangePromise_resolve = resolve2;
+        stream._backpressureChangePromise = newPromise((resolve4) => {
+          stream._backpressureChangePromise_resolve = resolve4;
         });
         stream._backpressure = backpressure;
       }
@@ -5525,8 +5526,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const readable = stream._readable;
-        controller._finishPromise = newPromise((resolve2, reject) => {
-          controller._finishPromise_resolve = resolve2;
+        controller._finishPromise = newPromise((resolve4, reject) => {
+          controller._finishPromise_resolve = resolve4;
           controller._finishPromise_reject = reject;
         });
         const cancelPromise = controller._cancelAlgorithm(reason);
@@ -5552,8 +5553,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const readable = stream._readable;
-        controller._finishPromise = newPromise((resolve2, reject) => {
-          controller._finishPromise_resolve = resolve2;
+        controller._finishPromise = newPromise((resolve4, reject) => {
+          controller._finishPromise_resolve = resolve4;
           controller._finishPromise_reject = reject;
         });
         const flushPromise = controller._flushAlgorithm();
@@ -5583,8 +5584,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const writable = stream._writable;
-        controller._finishPromise = newPromise((resolve2, reject) => {
-          controller._finishPromise_resolve = resolve2;
+        controller._finishPromise = newPromise((resolve4, reject) => {
+          controller._finishPromise_resolve = resolve4;
           controller._finishPromise_reject = reject;
         });
         const cancelPromise = controller._cancelAlgorithm(reason);
@@ -6126,23 +6127,23 @@ var init_from = __esm({
     import_node_domexception = __toESM(require_node_domexception());
     init_file();
     init_fetch_blob();
-    ({ stat } = fs4.promises);
-    blobFromSync = (path7, type) => fromBlob(fs4.statSync(path7), path7, type);
-    blobFrom = (path7, type) => stat(path7).then((stat2) => fromBlob(stat2, path7, type));
-    fileFrom = (path7, type) => stat(path7).then((stat2) => fromFile(stat2, path7, type));
-    fileFromSync = (path7, type) => fromFile(fs4.statSync(path7), path7, type);
-    fromBlob = (stat2, path7, type = "") => new fetch_blob_default([new BlobDataItem({
-      path: path7,
+    ({ stat } = fs6.promises);
+    blobFromSync = (path9, type) => fromBlob(fs6.statSync(path9), path9, type);
+    blobFrom = (path9, type) => stat(path9).then((stat2) => fromBlob(stat2, path9, type));
+    fileFrom = (path9, type) => stat(path9).then((stat2) => fromFile(stat2, path9, type));
+    fileFromSync = (path9, type) => fromFile(fs6.statSync(path9), path9, type);
+    fromBlob = (stat2, path9, type = "") => new fetch_blob_default([new BlobDataItem({
+      path: path9,
       size: stat2.size,
       lastModified: stat2.mtimeMs,
       start: 0
     })], { type });
-    fromFile = (stat2, path7, type = "") => new file_default([new BlobDataItem({
-      path: path7,
+    fromFile = (stat2, path9, type = "") => new file_default([new BlobDataItem({
+      path: path9,
       size: stat2.size,
       lastModified: stat2.mtimeMs,
       start: 0
-    })], path6.basename(path7), { type, lastModified: stat2.mtimeMs });
+    })], path8.basename(path9), { type, lastModified: stat2.mtimeMs });
     BlobDataItem = class _BlobDataItem {
       #path;
       #start;
@@ -6169,7 +6170,7 @@ var init_from = __esm({
         if (mtimeMs > this.lastModified) {
           throw new import_node_domexception.default("The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.", "NotReadableError");
         }
-        yield* fs4.createReadStream(this.#path, {
+        yield* fs6.createReadStream(this.#path, {
           start: this.#start,
           end: this.#start + this.size - 1
         });
@@ -7506,7 +7507,7 @@ __export(src_exports, {
   isRedirect: () => isRedirect
 });
 async function fetch2(url, options_) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve4, reject) => {
     const request = new Request(url, options_);
     const { parsedURL, options } = getNodeRequestOptions(request);
     if (!supportedSchemas.has(parsedURL.protocol)) {
@@ -7515,7 +7516,7 @@ async function fetch2(url, options_) {
     if (parsedURL.protocol === "data:") {
       const data2 = dist_default(request.url);
       const response3 = new Response(data2, { headers: { "Content-Type": data2.typeFull } });
-      resolve2(response3);
+      resolve4(response3);
       return;
     }
     const send = (parsedURL.protocol === "https:" ? https__default.default : http__default.default).request;
@@ -7637,7 +7638,7 @@ async function fetch2(url, options_) {
             if (responseReferrerPolicy) {
               requestOptions.referrerPolicy = responseReferrerPolicy;
             }
-            resolve2(fetch2(new Request(locationURL, requestOptions)));
+            resolve4(fetch2(new Request(locationURL, requestOptions)));
             finalize();
             return;
           }
@@ -7670,7 +7671,7 @@ async function fetch2(url, options_) {
       const codings = headers.get("Content-Encoding");
       if (!request.compress || request.method === "HEAD" || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
         response2 = new Response(body, responseOptions);
-        resolve2(response2);
+        resolve4(response2);
         return;
       }
       const zlibOptions = {
@@ -7684,7 +7685,7 @@ async function fetch2(url, options_) {
           }
         });
         response2 = new Response(body, responseOptions);
-        resolve2(response2);
+        resolve4(response2);
         return;
       }
       if (codings === "deflate" || codings === "x-deflate") {
@@ -7708,12 +7709,12 @@ async function fetch2(url, options_) {
             });
           }
           response2 = new Response(body, responseOptions);
-          resolve2(response2);
+          resolve4(response2);
         });
         raw.once("end", () => {
           if (!response2) {
             response2 = new Response(body, responseOptions);
-            resolve2(response2);
+            resolve4(response2);
           }
         });
         return;
@@ -7725,11 +7726,11 @@ async function fetch2(url, options_) {
           }
         });
         response2 = new Response(body, responseOptions);
-        resolve2(response2);
+        resolve4(response2);
         return;
       }
       response2 = new Response(body, responseOptions);
-      resolve2(response2);
+      resolve4(response2);
     });
     writeToStream(request_, request).catch(reject);
   });
@@ -7923,7 +7924,7 @@ var init_base_provider = __esm({
             }
             if (attempt < maxRetries - 1) {
               const delay = Math.pow(2, attempt) * 1e3;
-              await new Promise((resolve2) => setTimeout(resolve2, delay));
+              await new Promise((resolve4) => setTimeout(resolve4, delay));
             }
           }
         }
@@ -9468,7 +9469,7 @@ I'm here to assist you effectively!`;
             delay = 80;
           }
           if (i2 < lines.length - 1) {
-            await new Promise((resolve2) => setTimeout(resolve2, delay));
+            await new Promise((resolve4) => setTimeout(resolve4, delay));
           }
         }
       }
@@ -9569,52 +9570,1754 @@ var init_SlashCommandHandler = __esm({
         const resolvedName = this.aliases.get(name2) || name2;
         return this.commands.get(resolvedName);
       }
-      /**
-       * Search commands by pattern
-       */
-      searchCommands(pattern2) {
-        const lowercasePattern = pattern2.toLowerCase();
-        return this.listCommands().filter(
-          (cmd) => cmd.name.toLowerCase().includes(lowercasePattern) || cmd.description.toLowerCase().includes(lowercasePattern)
-        );
+      /**
+       * Search commands by pattern
+       */
+      searchCommands(pattern2) {
+        const lowercasePattern = pattern2.toLowerCase();
+        return this.listCommands().filter(
+          (cmd) => cmd.name.toLowerCase().includes(lowercasePattern) || cmd.description.toLowerCase().includes(lowercasePattern)
+        );
+      }
+      /**
+       * Get commands by category
+       */
+      getCommandsByCategory(category) {
+        return this.listCommands().filter((cmd) => cmd.category === category);
+      }
+      /**
+       * Get all categories
+       */
+      getCategories() {
+        const categories = /* @__PURE__ */ new Set();
+        for (const command of this.commands.values()) {
+          categories.add(command.category);
+        }
+        return Array.from(categories);
+      }
+      /**
+       * Validate command arguments
+       */
+      validateArgs(commandName, args) {
+        const command = this.getCommand(commandName);
+        if (!command) return false;
+        return true;
+      }
+      /**
+       * Create a helper context for testing
+       */
+      static createTestContext(deps, overrides) {
+        return {
+          command: "test",
+          args: [],
+          options: {},
+          deps,
+          signal: void 0,
+          ...overrides
+        };
+      }
+    };
+  }
+});
+var LogLevel, Logger, logger, envLogLevel;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+      LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+      LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+      LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+      LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+      LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
+      return LogLevel2;
+    })(LogLevel || {});
+    Logger = class {
+      level = 2 /* WARN */;
+      // Default to WARN to reduce noise
+      prefix = "[MARIA CODE]";
+      setLevel(level) {
+        this.level = level;
+      }
+      debug(...args) {
+        if (this.level <= 0 /* DEBUG */) {
+          console.log(chalk13__default.default.magenta(`${this.prefix} [DEBUG]`), ...args);
+        }
+      }
+      info(...args) {
+        if (this.level <= 1 /* INFO */) {
+          console.log(chalk13__default.default.bold.magenta(`${this.prefix} [INFO]`), ...args);
+        }
+      }
+      warn(...args) {
+        if (this.level <= 2 /* WARN */) {
+          console.warn(chalk13__default.default.bold.magenta(`${this.prefix} [WARN]`), ...args);
+        }
+      }
+      error(...args) {
+        if (this.level <= 3 /* ERROR */) {
+          console.error(chalk13__default.default.bold.magenta(`${this.prefix} [ERROR]`), ...args);
+        }
+      }
+      success(...args) {
+        if (this.level <= 1 /* INFO */) {
+          console.log(chalk13__default.default.bold.magenta(`${this.prefix} [SUCCESS]`), ...args);
+        }
+      }
+      task(taskName, status, message) {
+        if (this.level > 1 /* INFO */) {
+          return;
+        }
+        const statusIcons = {
+          start: "\u{1F680}",
+          progress: "\u23F3",
+          complete: "\u2705",
+          error: "\u274C"
+        };
+        const statusColors = {
+          start: chalk13__default.default.bold.magenta,
+          progress: chalk13__default.default.magenta,
+          complete: chalk13__default.default.bold.magenta,
+          error: chalk13__default.default.bold.magenta
+        };
+        const icon = statusIcons[status];
+        const color = statusColors[status];
+        const formattedMessage = message ? `: ${message}` : "";
+        console.log(color(`${this.prefix} ${icon} ${taskName}${formattedMessage}`));
+      }
+      table(data2) {
+        if (this.level > 1 /* INFO */) {
+          return;
+        }
+        console.table(data2);
+      }
+      json(obj, pretty = true) {
+        if (this.level > 0 /* DEBUG */) {
+          return;
+        }
+        console.log(chalk13__default.default.magenta(`${this.prefix} [JSON]`));
+        console.log(pretty ? JSON.stringify(obj, null, 2) : JSON.stringify(obj));
+      }
+      divider() {
+        if (this.level > 1 /* INFO */) {
+          return;
+        }
+        console.log(chalk13__default.default.magenta("\u2500".repeat(60)));
+      }
+      clear() {
+        console.clear();
+      }
+      /**
+       * プログレスバーを表示
+       */
+      progress(current, total, label) {
+        if (this.level > 1 /* INFO */) {
+          return;
+        }
+        const percentage = Math.round(current / total * 100);
+        const barLength = 30;
+        const filled = Math.round(percentage / 100 * barLength);
+        const empty = barLength - filled;
+        const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
+        const progressText = `${current}/${total}`;
+        const labelText = label ? ` ${label}` : "";
+        process.stdout.write(
+          `\r${chalk13__default.default.bold.magenta(bar)} ${percentage}% ${progressText}${labelText}`
+        );
+        if (current === total) {
+          process.stdout.write("\n");
+        }
+      }
+    };
+    logger = new Logger();
+    envLogLevel = process.env["MARIA_LOG_LEVEL"]?.toUpperCase();
+    if (envLogLevel && LogLevel[envLogLevel] !== void 0) {
+      logger.setLevel(LogLevel[envLogLevel]);
+    }
+  }
+});
+
+// src/slash-commands/base-command.ts
+var BaseCommand;
+var init_base_command = __esm({
+  "src/slash-commands/base-command.ts"() {
+    init_logger();
+    BaseCommand = class {
+      // Optional properties with defaults
+      aliases = [];
+      usage = "";
+      examples = [];
+      permissions;
+      middleware = [];
+      rateLimit;
+      // Metadata with defaults
+      metadata = {
+        version: "1.0.0",
+        author: "MARIA Team",
+        deprecated: false,
+        experimental: false
+      };
+      // Cache for frequently used data
+      cache = /* @__PURE__ */ new Map();
+      /**
+       * Initialize the command (called once when registered)
+       */
+      async initialize() {
+        logger.debug(`Initializing command: ${this.name}`);
+      }
+      /**
+       * Validate command arguments
+       */
+      async validate(_args) {
+        return { success: true };
+      }
+      /**
+       * Cleanup resources (called when command is unregistered)
+       */
+      async cleanup() {
+        this.cache.clear();
+        logger.debug(`Cleanup command: ${this.name}`);
+      }
+      /**
+       * Rollback on error - override for custom rollback logic
+       */
+      async rollback(_context, error) {
+        logger.error(`Rollback for ${this.name}:`, error);
+      }
+      // Helper methods for subclasses
+      /**
+       * Parse command arguments into structured format
+       */
+      parseArgs(raw) {
+        const args = {
+          raw,
+          parsed: Record,
+          flags: Record,
+          options: Record
+        };
+        for (let i2 = 0; i2 < raw.length; i2++) {
+          const _arg = raw[i2];
+          if (!_arg) {
+            continue;
+          }
+          if (_arg.startsWith("--")) {
+            const _key = _arg.slice(2);
+            const _nextArg = raw[i2 + 1];
+            if (_nextArg && !_nextArg.startsWith("-")) {
+              args.options[_key] = _nextArg;
+              i2++;
+            } else {
+              args.flags[_key] = true;
+            }
+          } else if (_arg && _arg.startsWith("-") && _arg.length === 2) {
+            args.flags[_arg.slice(1)] = true;
+          } else {
+            if (!args.parsed["positional"]) {
+              args.parsed["positional"] = [];
+            }
+            args.parsed["positional"].push(_arg);
+          }
+        }
+        return args;
+      }
+      /**
+       * Create a success response
+       */
+      success(message, data2, metadata) {
+        return {
+          success: true,
+          message,
+          data: data2,
+          metadata: {
+            executionTime: Date.now(),
+            commandVersion: this.metadata.version,
+            ...metadata
+          }
+        };
+      }
+      /**
+       * Create an error response
+       */
+      error(message, code, details) {
+        return {
+          success: false,
+          message,
+          data: { code, details },
+          metadata: {
+            executionTime: Date.now(),
+            commandVersion: this.metadata.version
+          }
+        };
+      }
+      /**
+       * Cache data with TTL
+       */
+      setCache(_key, data2, ttlSeconds = 60) {
+        this.cache.set(_key, {
+          data: data2,
+          expires: Date.now() + ttlSeconds * 1e3
+        });
+      }
+      /**
+       * Get _cached data
+       */
+      getCache(_key) {
+        const _cached = this.cache.get(_key);
+        if (!_cached) {
+          return null;
+        }
+        if (_cached.expires < Date.now()) {
+          this.cache.delete(_key);
+          return null;
+        }
+        return _cached.data;
+      }
+      /**
+       * Check if user has required permissions
+       */
+      async checkPermissions(context2) {
+        if (!this.permissions) {
+          return { success: true };
+        }
+        const { requiresAuth, requiresPremium, role } = this.permissions;
+        if (requiresAuth && !context2.user) {
+          return {
+            success: false,
+            error: "Authentication required",
+            suggestions: ["Run /login to authenticate"]
+          };
+        }
+        if (role && context2.user?.role !== role) {
+          return {
+            success: false,
+            error: `Required role: ${role}`,
+            suggestions: [`Contact admin for ${role} access`]
+          };
+        }
+        if (requiresPremium) {
+          logger.warn("Premium check not implemented");
+        }
+        return { success: true };
+      }
+      /**
+       * Format help text for this command
+       */
+      formatHelp() {
+        const lines = [];
+        lines.push(`\u{1F4D8} ${this.name.toUpperCase()}`);
+        lines.push("\u2500".repeat(40));
+        lines.push(`
+${this.description}
+`);
+        if (this.usage) {
+          lines.push("**Usage:**");
+          lines.push(`  /${this.name} ${this.usage}
+`);
+        }
+        if (this.aliases && this.aliases.length > 0) {
+          lines.push("**Aliases:**");
+          lines.push(`  ${this.aliases.map((a2) => `/${a2}`).join(", ")}
+`);
+        }
+        if (this.examples.length > 0) {
+          lines.push("**Examples:**");
+          this.examples.forEach((ex) => {
+            lines.push(`  ${ex.input}`);
+            lines.push(`    ${ex.description}`);
+            if (ex.output) {
+              lines.push(`    \u2192 ${ex.output}`);
+            }
+          });
+          lines.push("");
+        }
+        if (this.permissions) {
+          lines.push("**Requirements:**");
+          if (this.permissions.requiresAuth) {
+            lines.push("  \u2022 Authentication required");
+          }
+          if (this.permissions.role) {
+            lines.push(`  \u2022 Role: ${this.permissions.role}`);
+          }
+          if (this.permissions.requiresPremium) {
+            lines.push("  \u2022 Premium subscription");
+          }
+          lines.push("");
+        }
+        if (this.metadata.experimental) {
+          lines.push("\u26A0\uFE0F  **Experimental Feature**");
+        }
+        if (this.metadata.deprecated) {
+          lines.push(
+            `\u26A0\uFE0F  **Deprecated** - Use ${this.metadata.replacedBy || "alternative"} instead`
+          );
+        }
+        return lines.join("\n");
+      }
+      /**
+       * Log command execution
+       */
+      logExecution(args, context2, result) {
+        const _logData = {
+          command: this.name,
+          args: args.raw,
+          user: context2.user?.id,
+          success: result.success,
+          executionTime: result.metadata?.executionTime
+        };
+        if (result.success) {
+          logger.info("Command executed", _logData);
+        } else {
+          logger.error("Command failed", { ..._logData, error: result.message });
+        }
+      }
+    };
+  }
+});
+
+// src/slash-commands/help/metadata-validator.ts
+function validateHelpMetadata(container, opts = {}) {
+  const errors = [];
+  const warnings = [];
+  if (!isObject(container)) {
+    return fail("container is not an object");
+  }
+  const c = container;
+  if (!isInt(c.schemaVersion)) errors.push("schemaVersion must be an integer");
+  if (!isISO(c.generatedAt)) errors.push("generatedAt must be ISO-8601 string");
+  if (!Array.isArray(c.commands)) errors.push("commands must be an array");
+  const expected = opts.expectedSchemaVersion;
+  if (expected != null && c.schemaVersion !== expected) {
+    warnings.push(
+      `schemaVersion mismatch: meta=${c.schemaVersion}, expected=${expected}`
+    );
+  }
+  if (errors.length) {
+    return {
+      ok: false,
+      errors,
+      warnings,
+      counts: { commands: 0, categories: 0 }
+    };
+  }
+  const cmds = c.commands;
+  if (cmds.length === 0) errors.push("commands array is empty");
+  const nameSet = /* @__PURE__ */ new Set();
+  const aliasSet = /* @__PURE__ */ new Set();
+  const categorySet = /* @__PURE__ */ new Set();
+  for (const m2 of cmds) {
+    if (!m2 || !isObject(m2)) {
+      errors.push("command entry is not an object");
+      continue;
+    }
+    if (!isString(m2.name) || !m2.name.startsWith("/")) {
+      errors.push(`invalid name: ${JSON.stringify(m2?.name)}`);
+    } else if (nameSet.has(m2.name)) {
+      errors.push(`duplicated name: ${m2.name}`);
+    } else {
+      nameSet.add(m2.name);
+    }
+    if (!isString(m2.category) || !m2.category.trim()) {
+      errors.push(`invalid category for ${m2.name}`);
+    } else {
+      categorySet.add(m2.category);
+    }
+    if (!ALLOWED_LEVEL.includes(m2.level)) {
+      errors.push(`invalid level for ${m2.name}: ${m2.level}`);
+    }
+    if (m2.tags) {
+      for (const t2 of m2.tags) {
+        if (!ALLOWED_TAGS.includes(t2)) {
+          errors.push(`invalid tag "${t2}" on ${m2.name}`);
+        }
+      }
+    }
+    if (m2.usage) {
+      if (m2.usage.count != null && (!isInt(m2.usage.count) || m2.usage.count < 0)) {
+        errors.push(`usage.count must be non-negative int on ${m2.name}`);
+      }
+      if (m2.usage.frequency != null && !(typeof m2.usage.frequency === "number" && m2.usage.frequency >= 0)) {
+        errors.push(`usage.frequency must be non-negative number on ${m2.name}`);
+      }
+      if (m2.usage.lastUsed != null && !isISO(m2.usage.lastUsed)) {
+        errors.push(`usage.lastUsed must be ISO-8601 on ${m2.name}`);
+      }
+    }
+    if (m2.aliases) {
+      for (const a2 of m2.aliases) {
+        if (!isString(a2) || !a2.startsWith("/")) {
+          errors.push(
+            `invalid alias "${a2}" on ${m2.name} (must start with "/")`
+          );
+          continue;
+        }
+        if (nameSet.has(a2)) {
+          errors.push(`alias conflicts with existing name: ${a2} on ${m2.name}`);
+          continue;
+        }
+        if (aliasSet.has(a2)) {
+          errors.push(`duplicated alias across commands: ${a2} on ${m2.name}`);
+          continue;
+        }
+        aliasSet.add(a2);
+      }
+    }
+  }
+  const byName = new Map(cmds.map((m2) => [m2.name, m2]));
+  for (const m2 of cmds) {
+    if (m2.parent) {
+      if (!byName.has(m2.parent)) {
+        errors.push(`parent not found: ${m2.name} \u2192 ${m2.parent}`);
+      }
+      const computedDepth = computeDepth(m2, byName, errors);
+      if (m2.depth != null && m2.depth !== computedDepth) {
+        warnings.push(
+          `depth mismatch on ${m2.name}: meta=${m2.depth} computed=${computedDepth}`
+        );
+      }
+      if (opts.maxDepth != null && computedDepth > opts.maxDepth) {
+        warnings.push(
+          `depth exceeds maxDepth on ${m2.name}: ${computedDepth} > ${opts.maxDepth}`
+        );
+      }
+      if (m2.level === "primary") {
+        warnings.push(`command marked primary but has parent: ${m2.name}`);
+      }
+    } else {
+      if (m2.depth != null && m2.depth !== 0) {
+        warnings.push(`root command depth should be 0 on ${m2.name}`);
+      }
+    }
+  }
+  const seenGlobal = /* @__PURE__ */ new Set();
+  for (const m2 of cmds) {
+    if (seenGlobal.has(m2.name)) continue;
+    const cycle = detectCycle(m2, byName);
+    if (cycle) {
+      errors.push(`cycle detected: ${cycle.join(" -> ")}`);
+    }
+    seenGlobal.add(m2.name);
+  }
+  if (c.stats) {
+    if (c.stats.totalCommands != null && c.stats.totalCommands !== cmds.length) {
+      warnings.push(
+        `stats.totalCommands mismatch: meta=${c.stats.totalCommands} actual=${cmds.length}`
+      );
+    }
+    if (c.stats.totalCategories != null && c.stats.totalCategories !== categorySet.size) {
+      warnings.push(
+        `stats.totalCategories mismatch: meta=${c.stats.totalCategories} actual=${categorySet.size}`
+      );
+    }
+    if (c.stats.lastUpdated && !isISO(c.stats.lastUpdated)) {
+      warnings.push(`stats.lastUpdated must be ISO-8601`);
+    }
+  }
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    counts: {
+      commands: cmds.length,
+      categories: categorySet.size
+    }
+  };
+  function fail(msg) {
+    return {
+      ok: false,
+      errors: [msg],
+      warnings: [],
+      counts: { commands: 0, categories: 0 }
+    };
+  }
+}
+function isObject(x2) {
+  return !!x2 && typeof x2 === "object";
+}
+function isString(x2) {
+  return typeof x2 === "string";
+}
+function isInt(x2) {
+  return typeof x2 === "number" && Number.isInteger(x2);
+}
+function isISO(x2) {
+  if (typeof x2 !== "string") return false;
+  const d = new Date(x2);
+  return !Number.isNaN(d.getTime()) && /^\d{4}-\d{2}-\d{2}T/.test(x2);
+}
+function computeDepth(node2, byName, errors) {
+  let depth = 0;
+  const visited2 = /* @__PURE__ */ new Set();
+  let cur = node2;
+  while (cur?.parent) {
+    if (visited2.has(cur.name)) {
+      errors.push(`cycle while computing depth at ${cur.name}`);
+      break;
+    }
+    visited2.add(cur.name);
+    const p = byName.get(cur.parent);
+    if (!p) break;
+    depth++;
+    cur = p;
+    if (depth > 1e3) {
+      errors.push(`depth overflow at ${node2.name}`);
+      break;
+    }
+  }
+  return depth;
+}
+function detectCycle(start, byName) {
+  const stack = [];
+  const visiting = /* @__PURE__ */ new Set();
+  let cur = start;
+  while (cur) {
+    if (visiting.has(cur.name)) {
+      const idx = stack.indexOf(cur.name);
+      return idx >= 0 ? stack.slice(idx).concat(cur.name) : [cur.name, cur.name];
+    }
+    visiting.add(cur.name);
+    stack.push(cur.name);
+    if (!cur.parent) break;
+    cur = byName.get(cur.parent);
+  }
+  return null;
+}
+var ALLOWED_LEVEL, ALLOWED_TAGS;
+var init_metadata_validator = __esm({
+  "src/slash-commands/help/metadata-validator.ts"() {
+    ALLOWED_LEVEL = ["primary", "secondary", "hidden"];
+    ALLOWED_TAGS = ["core", "advanced", "experimental", "deprecated"];
+  }
+});
+var MetadataManager;
+var init_metadata_manager = __esm({
+  "src/slash-commands/help/metadata-manager.ts"() {
+    init_metadata_validator();
+    MetadataManager = class {
+      cache;
+      cacheTime;
+      CACHE_TTL = 5 * 60 * 1e3;
+      // 5 minutes
+      STALE_WARNING_MS = 7 * 864e5;
+      // 7 days
+      metaPath;
+      constructor(metaPath) {
+        this.metaPath = metaPath ?? path8__namespace.resolve("src/slash-commands/help/command-meta.json");
+      }
+      async load() {
+        if (this.cache && this.cacheTime && Date.now() - this.cacheTime < this.CACHE_TTL) {
+          return this.cache;
+        }
+        try {
+          const meta = await this.loadFromDisk();
+          const validation = validateHelpMetadata(meta, {
+            expectedSchemaVersion: 1
+          });
+          if (!validation.ok) {
+            console.error("[help] Metadata validation failed:", validation.errors);
+            throw new Error("Invalid metadata structure");
+          }
+          if (validation.warnings.length > 0) {
+            for (const warning of validation.warnings) {
+              console.warn(`[help] Warning: ${warning}`);
+            }
+          }
+          const age = Date.now() - new Date(meta.generatedAt).getTime();
+          if (age > this.STALE_WARNING_MS) {
+            console.warn(
+              "[help] Metadata stale (7d+), consider running: npx tsx scripts/generate-help-meta.ts"
+            );
+            this.triggerBackgroundRegeneration();
+          }
+          this.cache = meta;
+          this.cacheTime = Date.now();
+          return meta;
+        } catch (error) {
+          console.error("[help] Failed to load metadata:", error);
+          throw new Error(
+            `Metadata loading failed: ${error instanceof Error ? error.message : error}`
+          );
+        }
+      }
+      async loadFromDisk() {
+        const text = await fs8__namespace.readFile(this.metaPath, "utf8");
+        const data2 = JSON.parse(text);
+        if (Array.isArray(data2)) {
+          return {
+            schemaVersion: 1,
+            generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            generatorVersion: "legacy",
+            commands: data2,
+            stats: {
+              totalCommands: data2.length,
+              totalCategories: new Set(data2.map((c) => c.category)).size,
+              lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          };
+        }
+        return data2;
+      }
+      hasStaleCache() {
+        return !!this.cache;
+      }
+      getStaleCache() {
+        return this.cache;
+      }
+      triggerBackgroundRegeneration() {
+        try {
+          const child2 = child_process.spawn("npx", ["tsx", "scripts/generate-help-meta.ts"], {
+            detached: true,
+            stdio: "ignore"
+          });
+          child2.unref();
+          console.log("[help] Background metadata regeneration triggered");
+        } catch (error) {
+          console.warn("[help] Failed to trigger background regeneration:", error);
+        }
+      }
+      /**
+       * Build compact JSON for non-TTY output
+       */
+      buildCompactJson(metas) {
+        const byCat = /* @__PURE__ */ new Map();
+        for (const m2 of metas) {
+          if (m2.level === "hidden") continue;
+          const arr = byCat.get(m2.category) || [];
+          arr.push(m2);
+          byCat.set(m2.category, arr);
+        }
+        const categories = [];
+        for (const [cat, arr] of byCat) {
+          const primaries = arr.filter((x2) => x2.level === "primary" && !x2.parent).sort(
+            (a2, b) => (a2.rank ?? 1e9) - (b.rank ?? 1e9) || a2.name.localeCompare(b.name)
+          );
+          const top = primaries.slice(0, 3).map((p) => ({
+            name: p.name,
+            title: p.title
+          }));
+          const more = Math.max(0, primaries.length - top.length);
+          categories.push({
+            category: cat,
+            total: arr.length,
+            top,
+            more
+          });
+        }
+        categories.sort((a2, b) => a2.category.localeCompare(b.category));
+        return {
+          mode: "compact-json",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          categories
+        };
+      }
+    };
+  }
+});
+
+// src/slash-commands/help/renderers/compact-renderer.ts
+function renderCompactHelp(metas, opts = {}) {
+  const {
+    maxPrimaryPerCategory = 3,
+    maxCategories = 16,
+    showAdvanced = false,
+    twoColumnThreshold = 100,
+    categoryOrder,
+    heading = "\u{1F4D6} MARIA Commands (compact \u2022 primary only)"
+  } = opts;
+  const visible = metas.filter((m2) => showAdvanced || m2.level !== "hidden");
+  const byCat = /* @__PURE__ */ new Map();
+  for (const m2 of visible) {
+    const arr = byCat.get(m2.category) || [];
+    arr.push(m2);
+    byCat.set(m2.category, arr);
+  }
+  const compact = Array.from(byCat.entries()).map(([cat, arr]) => {
+    const primary = arr.filter((m2) => m2.level === "primary").sort(sorter2);
+    const total = arr.length;
+    const items = primary.slice(0, maxPrimaryPerCategory);
+    const more = Math.max(0, total - items.length);
+    return { category: cat, items, total, more };
+  });
+  compact.sort(
+    (a2, b) => categoryIndex(a2.category) - categoryIndex(b.category) || a2.category.localeCompare(b.category)
+  );
+  const limitedCompact = compact.slice(0, maxCategories);
+  const remainingCats = compact.length - limitedCompact.length;
+  const width = process.stdout.columns || 80;
+  const twoCol = width >= twoColumnThreshold && compact.length > 6;
+  const colPad = twoCol ? Math.floor(width / 2) : width;
+  const lines = [];
+  lines.push(heading, "");
+  let buffer = [];
+  function flushRow() {
+    if (!twoCol) {
+      lines.push(...buffer);
+      buffer = [];
+      return;
+    }
+    for (let i2 = 0; i2 < buffer.length; i2 += 2) {
+      const left = buffer[i2] ?? "";
+      const right = buffer[i2 + 1] ?? "";
+      const paddedLeft = left.padEnd(colPad - 1, " ");
+      lines.push(paddedLeft + right);
+    }
+    buffer = [];
+  }
+  for (const block of limitedCompact) {
+    const head = formatCategoryHeader(
+      block.category,
+      block.items.length,
+      block.total
+    );
+    const body = [
+      ...block.items.map(
+        (it) => `  ${padCmd3(it.name, 20)} ${truncate3(it.title ?? "", colPad - 24)}`
+      ),
+      block.more > 0 ? `  +${block.more} more  \u2192  /help ${block.category}` : ""
+    ].filter(Boolean);
+    const segment = [head, ...body, ""].join("\n");
+    if (twoCol) {
+      buffer.push(segment);
+      if (buffer.length === 2) flushRow();
+    } else {
+      lines.push(segment);
+    }
+  }
+  if (buffer.length) flushRow();
+  const totalCmds = metas.length;
+  const totalCats = byCat.size;
+  const footerLines = [
+    `Tip: /help <category> \u3067\u5C55\u958B, /help --search <kw>, /help --all${showAdvanced ? "" : ", /help --advanced"}`,
+    `Total: ${totalCmds} cmds / ${totalCats} cats (showing ${limitedCompact.length}/${totalCats} categories)`
+  ];
+  if (remainingCats > 0) {
+    footerLines.push(
+      `${remainingCats} more categories available with /help --all`
+    );
+  }
+  lines.push(...footerLines);
+  return lines.join("\n");
+  function sorter2(a2, b) {
+    if ((a2.rank ?? 999999) !== (b.rank ?? 999999))
+      return (a2.rank ?? 999999) - (b.rank ?? 999999);
+    return a2.name.localeCompare(b.name);
+  }
+  function categoryIndex(cat) {
+    if (!categoryOrder) return 0;
+    const idx = categoryOrder.indexOf(cat);
+    return idx === -1 ? 9999 : idx;
+  }
+  function formatCategoryHeader(cat, shown, total) {
+    const label = beautifyCategory3(cat);
+    return `${label} (${shown} of ${total})`;
+  }
+  function beautifyCategory3(cat) {
+    const map = {
+      core: "\u{1F4DD} Core",
+      generation: "\u{1F680} Content Generation",
+      analysis: "\u{1F50D} Analysis & Review",
+      quality: "\u{1F6E1}\uFE0F Code Quality",
+      development: "\u2699\uFE0F Development Tools",
+      workflow: "\u{1F504} Workflow Automation",
+      configuration: "\u{1F4CB} Configuration",
+      auth: "\u{1F510} Authentication",
+      media: "\u{1F3A8} Media Generation",
+      integration: "\u{1F517} Integration",
+      system: "\u{1F3E5} System & Diagnostics",
+      optimization: "\u26A1 Performance Optimization",
+      creative: "\u{1F3A8} Creative Tools",
+      implementation: "\u{1F527} Implementation Utilities",
+      evolution: "\u{1F9E0} RL Evolution",
+      ai: "\u{1F916} AI & GPU Operations",
+      monitoring: "\u{1F4CA} Real-time Monitoring",
+      file: "\u{1F4BE} File Operations",
+      "coding-agent": "\u{1F916} AI Coding Agent",
+      business: "\u{1F4BC} Business Operations"
+    };
+    return map[cat] ?? cat.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  }
+  function padCmd3(cmd, len) {
+    return cmd.padEnd(len, " ");
+  }
+  function truncate3(s2, max) {
+    if (s2.length <= max) return s2;
+    return s2.slice(0, Math.max(0, max - 1)) + "\u2026";
+  }
+}
+var init_compact_renderer = __esm({
+  "src/slash-commands/help/renderers/compact-renderer.ts"() {
+  }
+});
+
+// src/slash-commands/help/renderers/detail-renderer.ts
+function sorter(a2, b) {
+  if ((a2.rank ?? 999999) !== (b.rank ?? 999999))
+    return (a2.rank ?? 999999) - (b.rank ?? 999999);
+  return a2.name.localeCompare(b.name);
+}
+function beautifyCategory(cat) {
+  const map = {
+    core: "\u{1F4DD} Core",
+    generation: "\u{1F680} Content Generation",
+    analysis: "\u{1F50D} Analysis & Review",
+    quality: "\u{1F6E1}\uFE0F Code Quality",
+    development: "\u2699\uFE0F Development Tools",
+    workflow: "\u{1F504} Workflow Automation",
+    configuration: "\u{1F4CB} Configuration",
+    auth: "\u{1F510} Authentication",
+    media: "\u{1F3A8} Media Generation",
+    integration: "\u{1F517} Integration",
+    system: "\u{1F3E5} System & Diagnostics",
+    optimization: "\u26A1 Performance Optimization",
+    creative: "\u{1F3A8} Creative Tools",
+    implementation: "\u{1F527} Implementation Utilities",
+    evolution: "\u{1F9E0} RL Evolution",
+    ai: "\u{1F916} AI & GPU Operations",
+    monitoring: "\u{1F4CA} Real-time Monitoring",
+    file: "\u{1F4BE} File Operations",
+    "coding-agent": "\u{1F916} AI Coding Agent",
+    business: "\u{1F4BC} Business Operations"
+  };
+  return map[cat] ?? cat.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function padCmd(cmd, len) {
+  return cmd.padEnd(len, " ");
+}
+function truncate(s2, max) {
+  if (s2.length <= max) return s2;
+  return s2.slice(0, Math.max(0, max - 1)) + "\u2026";
+}
+function formatTags(m2) {
+  if (!m2.tags || m2.tags.length === 0) return "";
+  return "  [" + m2.tags.join(",") + "]";
+}
+function renderCategoryHelp(metas, category, opts = {}) {
+  const width = opts.width ?? process.stdout.columns ?? 80;
+  const colCmd = Math.min(24, Math.max(16, Math.floor(width * 0.28)));
+  const advanced = !!opts.advanced;
+  let target = metas.filter((m2) => m2.category === category);
+  if (!advanced) target = target.filter((m2) => m2.level !== "hidden");
+  const primary = target.filter((m2) => !m2.parent && m2.level !== "hidden" && m2.level !== "secondary").sort(sorter);
+  const secondaries = target.filter((m2) => m2.parent || m2.level === "secondary").sort(sorter);
+  const byParent = /* @__PURE__ */ new Map();
+  for (const s2 of secondaries) {
+    const p = s2.parent ?? "(misc)";
+    const arr = byParent.get(p) || [];
+    arr.push(s2);
+    byParent.set(p, arr);
+  }
+  const lines = [];
+  lines.push(
+    opts.heading ?? `\u{1F4D6} ${beautifyCategory(category)} \u2014 All Commands`,
+    ""
+  );
+  if (primary.length) {
+    lines.push("Primary:");
+    for (const p of primary) {
+      const alias = opts.showAliases && p.aliases?.length ? ` (aka: ${p.aliases.join(", ")})` : "";
+      const tags = formatTags(p);
+      lines.push(
+        `  ${padCmd(p.name, colCmd)} ${truncate((p.title ?? "") + alias + tags, width - colCmd - 4)}`
+      );
+    }
+    lines.push("");
+  }
+  const parentsSorted = Array.from(byParent.keys()).sort();
+  for (const parent of parentsSorted) {
+    const children = byParent.get(parent).sort(sorter);
+    const parentHead = parent !== "(misc)" ? parent : "Subcommands";
+    lines.push(`${parentHead}:`);
+    for (const c of children) {
+      const alias = opts.showAliases && c.aliases?.length ? ` (aka: ${c.aliases.join(", ")})` : "";
+      const tags = formatTags(c);
+      lines.push(
+        `  ${padCmd(c.name, colCmd)} ${truncate((c.title ?? "") + alias + tags, width - colCmd - 4)}`
+      );
+    }
+    lines.push("");
+  }
+  if (!primary.length && byParent.size === 0) {
+    lines.push("(No commands found in this category)");
+    lines.push("");
+  }
+  lines.push(
+    `Tip: /help --search <kw>, /help --all${advanced ? "" : ", /help --advanced"}`
+  );
+  return lines.join("\n");
+}
+function renderSearchHelp(metas, query, opts = {}) {
+  const width = opts.width ?? process.stdout.columns ?? 80;
+  const colCmd = Math.min(24, Math.max(16, Math.floor(width * 0.28)));
+  const advanced = !!opts.advanced;
+  const matchMode = opts.matchMode ?? "any";
+  const q = query.trim().toLowerCase();
+  if (!q) return "Please provide a search keyword.\n";
+  const pool = advanced ? metas : metas.filter((m2) => m2.level !== "hidden");
+  const matches2 = pool.map((m2) => ({ meta: m2, score: fuzzyScore(m2, q, matchMode) })).filter((x2) => x2.score > 0).sort(
+    (a2, b) => b.score - a2.score || (a2.meta.rank ?? 999999) - (b.meta.rank ?? 999999)
+  ).slice(0, 50);
+  const lines = [];
+  lines.push(`\u{1F50E} Search: "${query}" (${matches2.length} results)`, "");
+  if (matches2.length === 0) {
+    lines.push(
+      "No matches. Try another keyword or use --match all for stricter matching."
+    );
+    return lines.join("\n");
+  }
+  const byCat = /* @__PURE__ */ new Map();
+  for (const m2 of matches2) {
+    const arr = byCat.get(m2.meta.category) || [];
+    arr.push(m2);
+    byCat.set(m2.meta.category, arr);
+  }
+  const cats = Array.from(byCat.keys()).sort();
+  for (const cat of cats) {
+    lines.push(`${beautifyCategory(cat)}:`);
+    const arr = byCat.get(cat).sort((a2, b) => b.score - a2.score || sorter(a2.meta, b.meta));
+    for (const { meta } of arr) {
+      const alias = opts.showAliases && meta.aliases?.length ? ` (aka: ${meta.aliases.join(", ")})` : "";
+      const tags = formatTags(meta);
+      const badge = meta.level === "secondary" ? "\xB7 " : "";
+      lines.push(
+        `  ${badge}${padCmd(meta.name, colCmd)} ${truncate((meta.title ?? "") + alias + tags, width - colCmd - 6)}`
+      );
+    }
+    lines.push("");
+  }
+  lines.push(
+    `Tip: /help <category> \u3067\u8A72\u5F53\u30AB\u30C6\u30B4\u30EA\u3092\u5C55\u958B, /help --all${advanced ? "" : ", /help --advanced"}`
+  );
+  return lines.join("\n");
+  function fuzzyScore(m2, q2, mode) {
+    const tokens = q2.split(/\s+/).filter(Boolean);
+    [
+      m2.name.toLowerCase(),
+      (m2.title ?? "").toLowerCase(),
+      m2.category.toLowerCase(),
+      ...(m2.aliases ?? []).map((a2) => a2.toLowerCase())
+    ].join(" | ");
+    let totalScore = 0;
+    let matchedTokens = 0;
+    for (const token of tokens) {
+      let tokenScore = 0;
+      if (m2.name.toLowerCase() === token || m2.name.toLowerCase() === "/" + token) {
+        tokenScore = 1e4;
+      } else if (m2.aliases?.some(
+        (a2) => a2.toLowerCase() === token || a2.toLowerCase() === "/" + token
+      )) {
+        tokenScore = 8e3;
+      } else if (m2.name.toLowerCase().startsWith("/" + token)) {
+        tokenScore = 5e3;
+      } else if (m2.name.toLowerCase().includes(token)) {
+        tokenScore = 3e3;
+      } else if (m2.name.split(/[\s\/]+/).some((w) => w.toLowerCase().startsWith(token))) {
+        tokenScore = 2e3;
+      } else if (m2.title?.toLowerCase().includes(token)) {
+        tokenScore = 1e3;
+      } else if (m2.category.toLowerCase().includes(token)) {
+        tokenScore = 500;
+      }
+      if (tokenScore > 0) {
+        matchedTokens++;
+        totalScore += tokenScore;
+      }
+    }
+    if (mode === "all" && matchedTokens < tokens.length) {
+      return 0;
+    }
+    if (mode === "any" && matchedTokens === 0) {
+      return 0;
+    }
+    if (m2.usage?.frequency) {
+      totalScore *= 1 + Math.min(m2.usage.frequency / 100, 2);
+    }
+    if (m2.tags?.includes("deprecated")) totalScore *= 0.5;
+    if (m2.tags?.includes("experimental")) totalScore *= 0.8;
+    return totalScore;
+  }
+}
+var init_detail_renderer = __esm({
+  "src/slash-commands/help/renderers/detail-renderer.ts"() {
+  }
+});
+
+// src/slash-commands/help/renderers/full-renderer.ts
+function renderFullHelp(metas, opts = {}) {
+  const {
+    advanced = false,
+    showAliases = false,
+    categoryOrder,
+    heading = "\u{1F4D6} MARIA Commands \u2014 Full Listing"
+  } = opts;
+  const width = opts.width ?? process.stdout.columns ?? 80;
+  const colCmd = Math.min(28, Math.max(16, Math.floor(width * 0.3)));
+  const visible = advanced ? metas : metas.filter((m2) => m2.level !== "hidden");
+  const byCat = /* @__PURE__ */ new Map();
+  for (const m2 of visible) {
+    const arr = byCat.get(m2.category) || [];
+    arr.push(m2);
+    byCat.set(m2.category, arr);
+  }
+  const cats = Array.from(byCat.keys()).sort(
+    (a2, b) => categoryIndex(a2) - categoryIndex(b) || a2.localeCompare(b)
+  );
+  const out = [];
+  out.push(heading, "");
+  for (const cat of cats) {
+    const list = (byCat.get(cat) || []).slice().sort(sorter2);
+    const primaries = list.filter((m2) => m2.level === "primary" && !m2.parent);
+    const secondaries = list.filter((m2) => m2.level !== "primary" || m2.parent);
+    out.push(`${beautifyCategory3(cat)} (${list.length})`, "");
+    if (primaries.length) {
+      out.push("Primary:");
+      for (const p of primaries) {
+        out.push(`  ${padCmd3(p.name, colCmd)} ${fmtDesc(p)}`);
+      }
+      out.push("");
+    }
+    if (secondaries.length) {
+      const byParent = /* @__PURE__ */ new Map();
+      for (const s2 of secondaries) {
+        const k = s2.parent ?? "(misc)";
+        const arr = byParent.get(k) || [];
+        arr.push(s2);
+        byParent.set(k, arr);
+      }
+      const parents = Array.from(byParent.keys()).sort();
+      for (const parent of parents) {
+        const label = parent !== "(misc)" ? parent : "Subcommands";
+        out.push(`${label}:`);
+        const children = (byParent.get(parent) || []).slice().sort(sorter2);
+        for (const c of children) {
+          out.push(`  ${padCmd3(c.name, colCmd)} ${fmtDesc(c)}`);
+        }
+        out.push("");
+      }
+    }
+    out.push("");
+  }
+  out.push(
+    `Tip: /help <category> \u3067\u30AB\u30C6\u30B4\u30EA\u5225\u3001/help --search <kw> \u3067\u7D5E\u308A\u8FBC\u307F\u3001/help \u3067\u30B3\u30F3\u30D1\u30AF\u30C8\u8868\u793A`,
+    `Total: ${metas.length} commands across ${cats.length} categories${advanced ? " (advanced shown)" : ""}`
+  );
+  return out.join("\n");
+  function sorter2(a2, b) {
+    if ((a2.rank ?? 999999) !== (b.rank ?? 999999))
+      return (a2.rank ?? 999999) - (b.rank ?? 999999);
+    return a2.name.localeCompare(b.name);
+  }
+  function categoryIndex(cat) {
+    if (!categoryOrder) return 0;
+    const i2 = categoryOrder.indexOf(cat);
+    return i2 === -1 ? 9999 : i2;
+  }
+  function beautifyCategory3(cat) {
+    const map = {
+      core: "\u{1F4DD} Core",
+      generation: "\u{1F680} Content Generation",
+      analysis: "\u{1F50D} Analysis & Review",
+      quality: "\u{1F6E1}\uFE0F Code Quality",
+      development: "\u2699\uFE0F Development Tools",
+      workflow: "\u{1F504} Workflow Automation",
+      configuration: "\u{1F4CB} Configuration",
+      auth: "\u{1F510} Authentication",
+      media: "\u{1F3A8} Media Generation",
+      integration: "\u{1F517} Integration",
+      system: "\u{1F3E5} System & Diagnostics",
+      optimization: "\u26A1 Performance Optimization",
+      creative: "\u{1F3A8} Creative Tools",
+      implementation: "\u{1F527} Implementation Utilities",
+      evolution: "\u{1F9E0} RL Evolution",
+      ai: "\u{1F916} AI & GPU Operations",
+      monitoring: "\u{1F4CA} Real-time Monitoring",
+      file: "\u{1F4BE} File Operations",
+      "coding-agent": "\u{1F916} AI Coding Agent",
+      business: "\u{1F4BC} Business Operations"
+    };
+    return map[cat] ?? cat.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  }
+  function padCmd3(cmd, len) {
+    return cmd.padEnd(len, " ");
+  }
+  function truncate3(s2, max) {
+    if (s2.length <= max) return s2;
+    return s2.slice(0, Math.max(0, max - 1)) + "\u2026";
+  }
+  function fmtDesc(m2) {
+    const alias = showAliases && m2.aliases?.length ? ` (aka: ${m2.aliases.join(", ")})` : "";
+    const tags = m2.tags && m2.tags.length ? `  [${m2.tags.join(",")}]` : "";
+    const text = ((m2.title ?? "") + alias + tags).trim();
+    return truncate3(text, Math.max(8, width - colCmd - 4));
+  }
+}
+var init_full_renderer = __esm({
+  "src/slash-commands/help/renderers/full-renderer.ts"() {
+  }
+});
+async function runInteractiveHelp(opts = {}) {
+  const metaPath = opts.metaPath ?? path8__namespace.resolve("src/slash-commands/help/command-meta.json");
+  let container;
+  try {
+    const text = await fs8__namespace.readFile(metaPath, "utf8");
+    container = JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Failed to load metadata: ${error}`);
+  }
+  const metas = Array.isArray(container) ? container : container.commands;
+  if (!Array.isArray(metas) || metas.length === 0) {
+    throw new Error("help meta not found or empty");
+  }
+  const state = buildState(
+    metas,
+    !!opts.showAdvancedDefault,
+    opts.heading ?? "\u{1F4D6} MARIA Commands \u2014 Interactive"
+  );
+  const term = new Terminal();
+  try {
+    if (!process.stdout.isTTY || process.env.NO_ALT_SCREEN) {
+      throw new Error("Interactive mode requires TTY with alt screen support");
+    }
+    term.enterAlt();
+    term.hideCursor();
+    term.enableRaw();
+    render(term, state);
+    await loop(term, state);
+  } finally {
+    term.disableRaw();
+    term.showCursor();
+    term.leaveAlt();
+  }
+}
+function buildState(metas, showAdvanced, heading) {
+  const width = process.stdout.columns || 80;
+  const height = process.stdout.rows || 24;
+  const visible = showAdvanced ? metas : metas.filter((m2) => m2.level !== "hidden");
+  const byCat = /* @__PURE__ */ new Map();
+  for (const m2 of visible) {
+    const arr = byCat.get(m2.category) || [];
+    arr.push(m2);
+    byCat.set(m2.category, arr);
+  }
+  const blocks = [];
+  for (const [cat, arr] of byCat) {
+    const sorted = arr.slice().sort(sorter2);
+    const primaries = sorted.filter((m2) => m2.level === "primary" && !m2.parent);
+    const secondaries = sorted.filter((m2) => m2.level !== "primary" || m2.parent);
+    blocks.push({
+      key: cat,
+      label: beautifyCategory2(cat),
+      total: sorted.length,
+      primaries,
+      secondaries
+    });
+  }
+  const order = blocks.map((b) => b.key).sort((a2, b) => a2.localeCompare(b));
+  return {
+    heading,
+    width,
+    height,
+    categories: blocks,
+    order,
+    selected: 0,
+    expanded: /* @__PURE__ */ new Set(),
+    scrollTop: 0,
+    showAdvanced
+  };
+  function sorter2(a2, b) {
+    if ((a2.rank ?? 999999) !== (b.rank ?? 999999))
+      return (a2.rank ?? 999999) - (b.rank ?? 999999);
+    return a2.name.localeCompare(b.name);
+  }
+}
+function beautifyCategory2(cat) {
+  const map = {
+    core: "\u{1F4DD} Core",
+    generation: "\u{1F680} Content Generation",
+    analysis: "\u{1F50D} Analysis & Review",
+    quality: "\u{1F6E1}\uFE0F Code Quality",
+    development: "\u2699\uFE0F Development Tools",
+    workflow: "\u{1F504} Workflow Automation",
+    configuration: "\u{1F4CB} Configuration",
+    auth: "\u{1F510} Authentication",
+    media: "\u{1F3A8} Media Generation",
+    integration: "\u{1F517} Integration",
+    system: "\u{1F3E5} System & Diagnostics",
+    optimization: "\u26A1 Performance Optimization",
+    creative: "\u{1F3A8} Creative Tools",
+    implementation: "\u{1F527} Implementation Utilities",
+    evolution: "\u{1F9E0} RL Evolution",
+    ai: "\u{1F916} AI & GPU Operations",
+    monitoring: "\u{1F4CA} Real-time Monitoring",
+    file: "\u{1F4BE} File Operations",
+    "coding-agent": "\u{1F916} AI Coding Agent",
+    business: "\u{1F4BC} Business Operations"
+  };
+  return map[cat] ?? cat.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+async function loop(term, s2) {
+  let last = 0;
+  const onKey = async (buf) => {
+    const now = Date.now();
+    if (now - last < 25) return;
+    last = now;
+    const str = buf.toString();
+    if (str === KEY.UP) {
+      s2.selected = Math.max(0, s2.selected - 1);
+      ensureVisible(s2);
+      render(term, s2);
+      return;
+    }
+    if (str === KEY.DOWN) {
+      s2.selected = Math.min(s2.order.length - 1, s2.selected + 1);
+      ensureVisible(s2);
+      render(term, s2);
+      return;
+    }
+    if (str === KEY.RIGHT || str === KEY.ENTER) {
+      toggleExpand(s2, true);
+      ensureVisible(s2);
+      render(term, s2);
+      return;
+    }
+    if (str === KEY.LEFT) {
+      toggleExpand(s2, false);
+      ensureVisible(s2);
+      render(term, s2);
+      return;
+    }
+    if (str.toLowerCase() === KEY.A) {
+      s2.showAdvanced = !s2.showAdvanced;
+      render(term, s2);
+      return;
+    }
+    if (str.toLowerCase() === KEY.D) {
+      await showCategoryDetail(term, s2);
+      render(term, s2);
+      return;
+    }
+    if (str.toLowerCase() === KEY.F) {
+      await showFullDetail(term, s2);
+      render(term, s2);
+      return;
+    }
+    if (str === KEY.ESC || str.toLowerCase() === KEY.Q) {
+      term.writeAt(1, 1, "");
+      throw new ExitSignal();
+    }
+  };
+  try {
+    await term.onKey(onKey);
+  } catch (e2) {
+    if (!(e2 instanceof ExitSignal)) throw e2;
+  }
+}
+function toggleExpand(s2, open) {
+  const cat = s2.order[s2.selected];
+  if (!cat) return;
+  const isOpen = s2.expanded.has(cat);
+  if (open && !isOpen) s2.expanded.add(cat);
+  if (!open && isOpen) s2.expanded.delete(cat);
+}
+function ensureVisible(s2) {
+  materializeLines(s2);
+  const indexLine = findCategoryTopLine(s2, s2.order[s2.selected]);
+  const top = s2.scrollTop;
+  const bottom = s2.scrollTop + (s2.height - 4);
+  if (indexLine < top) s2.scrollTop = indexLine;
+  else if (indexLine > bottom - 3) s2.scrollTop = indexLine - (s2.height - 4) + 3;
+  if (s2.scrollTop < 0) s2.scrollTop = 0;
+}
+function render(term, s2) {
+  const lines = materializeLines(s2);
+  const maxLines = s2.height - 2;
+  term.clearAll();
+  term.moveTo(1, 1);
+  term.write(`${s2.heading}  ${s2.showAdvanced ? "[ADVANCED: ON]" : ""}`);
+  term.write("\n");
+  const start = s2.scrollTop;
+  const end = Math.min(lines.length, start + maxLines - 2);
+  for (let i2 = start; i2 < end; i2++) {
+    term.write(lines[i2] + "\n");
+  }
+  const footer = "\u2191/\u2193 Move  \u2192/Enter Expand  \u2190 Collapse  [A]dvanced  [D]etail  [F]ull  [Q/Esc] Quit";
+  term.write(truncateWidth(footer, s2.width));
+}
+function materializeLines(s2) {
+  const lines = [];
+  const selCat = s2.order[s2.selected];
+  for (const key2 of s2.order) {
+    const block = s2.categories.find((b) => b.key === key2);
+    const isOpen = s2.expanded.has(key2);
+    const isSel = key2 === selCat;
+    const head = `${isOpen ? "\u25BC" : "\u25B6"} ${block.label} (${block.primaries.length + block.secondaries.length})`;
+    lines.push(colorize(isSel, head));
+    if (isOpen) {
+      for (const p of block.primaries) {
+        lines.push(
+          "   " + padCmd2(p.name, 24) + " " + truncate2(p.title ?? "", 80)
+        );
+      }
+      const byParent = /* @__PURE__ */ new Map();
+      for (const sc of block.secondaries) {
+        const parent = sc.parent ?? "(misc)";
+        const arr = byParent.get(parent) || [];
+        arr.push(sc);
+        byParent.set(parent, arr);
+      }
+      const parents = Array.from(byParent.keys()).sort();
+      for (const parent of parents) {
+        lines.push(`   ${parent !== "(misc)" ? parent : "Subcommands"}:`);
+        const children = (byParent.get(parent) || []).slice().sort(
+          (a2, b) => (a2.rank ?? 999999) - (b.rank ?? 999999) || a2.name.localeCompare(b.name)
+        );
+        for (const c of children) {
+          lines.push(
+            "     " + padCmd2(c.name, 24) + " " + truncate2(c.title ?? "", 76)
+          );
+        }
+      }
+      lines.push("");
+    }
+  }
+  return lines;
+}
+function findCategoryTopLine(s2, cat, lines) {
+  let cursor = 0;
+  for (const key2 of s2.order) {
+    if (key2 === cat) return cursor;
+    cursor++;
+    const isOpen = s2.expanded.has(key2);
+    if (isOpen) {
+      const b = s2.categories.find((x2) => x2.key === key2);
+      cursor += b.primaries.length;
+      const byParent = /* @__PURE__ */ new Map();
+      for (const sc of b.secondaries) {
+        const parent = sc.parent ?? "(misc)";
+        const arr = byParent.get(parent) || [];
+        arr.push(sc);
+        byParent.set(parent, arr);
+      }
+      cursor += byParent.size;
+      for (const arr of byParent.values()) {
+        cursor += arr.length;
+      }
+      cursor += 1;
+    }
+  }
+  return 0;
+}
+function padCmd2(cmd, len) {
+  return cmd.padEnd(len, " ");
+}
+function truncate2(s2, max) {
+  if (s2.length <= max) return s2;
+  return s2.slice(0, Math.max(0, max - 1)) + "\u2026";
+}
+function truncateWidth(s2, width) {
+  return s2.length <= width ? s2 : s2.slice(0, width - 1) + "\u2026";
+}
+function colorize(selected, text) {
+  if (process.env.NO_COLOR) return selected ? `> ${text}` : `  ${text}`;
+  const B = "\x1B[1m", R = "\x1B[0m", C = selected ? "\x1B[36m" : "";
+  return selected ? `${B}${C}> ${text}${R}` : `  ${text}`;
+}
+async function showCategoryDetail(term, s2) {
+  const cat = s2.order[s2.selected];
+  if (!cat) return;
+  const metas = s2.showAdvanced ? collectAll(s2, cat) : collectAll(s2, cat).filter((m2) => m2.level !== "hidden");
+  const txt = renderCategoryHelp(metas, cat, {
+    advanced: s2.showAdvanced,
+    showAliases: false,
+    width: s2.width
+  });
+  term.clearAll();
+  term.moveTo(1, 1);
+  term.write(txt + "\n\n");
+  term.write("Press any key to return...");
+  await term.waitKey();
+}
+async function showFullDetail(term, s2) {
+  const metas = s2.showAdvanced ? collectAll(s2) : collectAll(s2).filter((m2) => m2.level !== "hidden");
+  const txt = renderFullHelp(metas, {
+    advanced: s2.showAdvanced,
+    showAliases: false,
+    heading: "\u{1F4D6} Full Listing",
+    width: s2.width
+  });
+  term.clearAll();
+  term.moveTo(1, 1);
+  term.write(txt + "\n\n");
+  term.write("Press any key to return...");
+  await term.waitKey();
+}
+function collectAll(s2, onlyCat) {
+  const arr = [];
+  for (const key2 of s2.order) {
+    if (onlyCat && key2 !== onlyCat) continue;
+    const b = s2.categories.find((x2) => x2.key === key2);
+    arr.push(...b.primaries, ...b.secondaries);
+  }
+  return arr;
+}
+var KEY, ExitSignal, Terminal;
+var init_interactive_help = __esm({
+  "src/slash-commands/help/interactive-help.ts"() {
+    init_detail_renderer();
+    init_full_renderer();
+    KEY = {
+      UP: "\x1B[A",
+      DOWN: "\x1B[B",
+      RIGHT: "\x1B[C",
+      LEFT: "\x1B[D",
+      ENTER: "\r",
+      ESC: "\x1B",
+      Q: "q",
+      A: "a",
+      D: "d",
+      F: "f"
+    };
+    ExitSignal = class extends Error {
+    };
+    Terminal = class {
+      keyHandler;
+      enterAlt() {
+        this.write("\x1B[?1049h");
+      }
+      leaveAlt() {
+        this.write("\x1B[?1049l");
+      }
+      hideCursor() {
+        this.write("\x1B[?25l");
+      }
+      showCursor() {
+        this.write("\x1B[?25h");
+      }
+      enableRaw() {
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(true);
+          process.stdin.resume();
+        }
+      }
+      disableRaw() {
+        try {
+          if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+          }
+        } catch {
+        }
+      }
+      clearAll() {
+        this.write("\x1B[2J\x1B[H");
+      }
+      moveTo(row, col) {
+        this.write(`\x1B[${row};${col}H`);
+      }
+      write(s2) {
+        process.stdout.write(s2);
       }
-      /**
-       * Get commands by category
-       */
-      getCommandsByCategory(category) {
-        return this.listCommands().filter((cmd) => cmd.category === category);
+      writeAt(row, col, s2) {
+        this.moveTo(row, col);
+        this.write(s2);
       }
-      /**
-       * Get all categories
-       */
-      getCategories() {
-        const categories = /* @__PURE__ */ new Set();
-        for (const command of this.commands.values()) {
-          categories.add(command.category);
-        }
-        return Array.from(categories);
+      async onKey(handler) {
+        this.keyHandler = handler;
+        return new Promise((resolve4, reject) => {
+          const onData = (b) => handler(b);
+          const onErr = (e2) => reject(e2);
+          process.stdin.on("data", onData);
+          process.stdin.on("error", onErr);
+          const cleanup = () => {
+            process.stdin.off("data", onData);
+            process.stdin.off("error", onErr);
+          };
+          this._cleanup = cleanup;
+        });
       }
-      /**
-       * Validate command arguments
-       */
-      validateArgs(commandName, args) {
-        const command = this.getCommand(commandName);
-        if (!command) return false;
-        return true;
+      async waitKey() {
+        return new Promise((res) => {
+          const handler = (b) => {
+            process.stdin.off("data", handler);
+            res();
+          };
+          process.stdin.on("data", handler);
+        });
       }
-      /**
-       * Create a helper context for testing
-       */
-      static createTestContext(deps, overrides) {
+    };
+  }
+});
+
+// src/slash-commands/help/HelpCommand.ts
+var HelpCommandV2;
+var init_HelpCommand = __esm({
+  "src/slash-commands/help/HelpCommand.ts"() {
+    init_base_command();
+    init_metadata_manager();
+    init_compact_renderer();
+    init_detail_renderer();
+    init_full_renderer();
+    init_interactive_help();
+    HelpCommandV2 = class extends BaseCommand {
+      name = "help";
+      category = "core";
+      description = "Show help information and command list with progressive disclosure";
+      aliases = ["h", "?"];
+      usage = "[<category>] [--search <kw>] [--all] [--advanced] [--interactive] [--json]";
+      examples = [
+        { input: "/help", description: "Compact view (Top 3 per category)" },
+        { input: "/help business", description: "Category expansion" },
+        { input: "/help --search sow", description: "Search across categories" },
+        { input: "/help --all", description: "Full listing" },
+        {
+          input: "/help --interactive",
+          description: "TUI mode with arrow navigation"
+        },
+        { input: "/help --json", description: "JSON output for automation" }
+      ];
+      metadataManager = new MetadataManager();
+      async execute(args, _context) {
+        const flags = this.parseFlags(args);
+        try {
+          const container = await this.metadataManager.load();
+          const metas = container.commands;
+          const isTTY = !!(process.stdout.isTTY && process.stdin.isTTY);
+          if ((!isTTY || flags.json) && !flags.interactive) {
+            const payload = this.metadataManager.buildCompactJson(metas);
+            return this.success(JSON.stringify(payload, null, 2));
+          }
+          if (flags.interactive) {
+            try {
+              await runInteractiveHelp({
+                showAdvancedDefault: flags.advanced
+              });
+              return this.success("");
+            } catch (error) {
+              if (error.message?.includes("TTY")) {
+                return this.error(
+                  "Interactive mode requires a TTY terminal",
+                  "HELP_NO_TTY"
+                );
+              }
+              return this.error(
+                "Interactive help failed",
+                "HELP_INTERACTIVE_ERROR",
+                error?.message
+              );
+            }
+          }
+          let output3 = "";
+          if (flags.search) {
+            output3 = renderSearchHelp(metas, flags.search, {
+              advanced: flags.advanced,
+              showAliases: flags.aliases,
+              matchMode: flags.matchMode || "any"
+            });
+          } else if (flags.category) {
+            output3 = renderCategoryHelp(metas, flags.category, {
+              advanced: flags.advanced,
+              showAliases: flags.aliases
+            });
+          } else if (flags.all) {
+            output3 = renderFullHelp(metas, {
+              advanced: flags.advanced,
+              showAliases: flags.aliases,
+              heading: "\u{1F4D6} MARIA Commands \u2014 Full Listing"
+            });
+          } else {
+            output3 = renderCompactHelp(metas, {
+              maxPrimaryPerCategory: 3,
+              showAdvanced: flags.advanced,
+              twoColumnThreshold: 100,
+              heading: "\u{1F4D6} MARIA Commands (compact \u2022 primary only)"
+            });
+          }
+          return this.success(output3);
+        } catch (error) {
+          return this.handleError(error);
+        }
+      }
+      parseFlags(args) {
+        const { parsed, options, flags } = args;
+        const positional = parsed?.positional || [];
+        const category = positional[0] && !positional[0].startsWith("-") ? positional[0] : void 0;
         return {
-          command: "test",
-          args: [],
-          options: {},
-          deps,
-          signal: void 0,
-          ...overrides
+          category,
+          search: this.getStringOption(options, "search"),
+          all: this.getBoolFlag(options, flags, "all"),
+          advanced: this.getBoolFlag(options, flags, "advanced"),
+          aliases: this.getBoolFlag(options, flags, "aliases"),
+          interactive: this.getBoolFlag(options, flags, "interactive"),
+          json: this.getBoolFlag(options, flags, "json"),
+          matchMode: this.getStringOption(options, "match") || "any"
         };
       }
+      getBoolFlag(options, flags, key2) {
+        const optValue = options?.[key2];
+        const flagValue = flags?.[key2];
+        if (typeof optValue === "boolean") return optValue;
+        if (typeof flagValue === "boolean") return flagValue;
+        if (typeof optValue === "string")
+          return optValue === "true" || optValue === "";
+        if (typeof flagValue === "string")
+          return flagValue === "true" || flagValue === "";
+        return !!optValue || !!flagValue;
+      }
+      getStringOption(options, key2) {
+        const value = options?.[key2];
+        return typeof value === "string" ? value : void 0;
+      }
+      handleError(error) {
+        console.error("[help] Command failed:", error);
+        if (this.metadataManager.hasStaleCache()) {
+          console.warn("[help] Using stale cache as fallback");
+          try {
+            const staleContainer = this.metadataManager.getStaleCache();
+            if (staleContainer) {
+              const output3 = renderCompactHelp(staleContainer.commands, {
+                heading: "\u{1F4D6} MARIA Commands (using cached data - may be outdated)"
+              });
+              return this.success(
+                output3 + "\n\n\u26A0\uFE0F  Using stale cache. Run: npx tsx scripts/generate-help-meta.ts"
+              );
+            }
+          } catch (fallbackError) {
+            console.error("[help] Stale cache fallback failed:", fallbackError);
+          }
+        }
+        const fallbackHelp = [
+          "\u{1F4D6} MARIA Commands",
+          "",
+          "Help metadata unavailable.",
+          `Reason: ${error?.message || error}`,
+          "",
+          "Try:",
+          "  \u2022 npx tsx scripts/generate-help-meta.ts",
+          "  \u2022 Check that command-meta.json exists and is valid",
+          "",
+          "For immediate help, use individual command --help flags.",
+          ""
+        ].join("\n");
+        return this.success(fallbackHelp);
+      }
+      async validate(args) {
+        const flags = this.parseFlags(args);
+        if (flags.search !== void 0 && (flags.search === "" || flags.search.length < 2)) {
+          return {
+            success: false,
+            error: "Search term must be at least 2 characters long"
+          };
+        }
+        if (flags.matchMode && !["any", "all"].includes(flags.matchMode)) {
+          return {
+            success: false,
+            error: 'Match mode must be either "any" or "all"'
+          };
+        }
+        if (flags.interactive && !process.stdout.isTTY) {
+          return {
+            success: false,
+            error: "Interactive mode requires a TTY terminal"
+          };
+        }
+        return { success: true };
+      }
     };
   }
 });
@@ -9624,6 +11327,7 @@ var LegacySlashCommandAdapter, SlashCommandHandler2;
 var init_LegacySlashCommandAdapter = __esm({
   "src/shared/adapters/LegacySlashCommandAdapter.ts"() {
     init_SlashCommandHandler();
+    init_HelpCommand();
     LegacySlashCommandAdapter = class _LegacySlashCommandAdapter {
       static instance = null;
       handler;
@@ -9635,6 +11339,7 @@ var init_LegacySlashCommandAdapter = __esm({
           ui: null
         };
         this.handler = new SlashCommandHandlerV2(deps);
+        this.registerEssentialCommands();
       }
       /**
        * Legacy getInstance method for backward compatibility
@@ -9694,6 +11399,48 @@ var init_LegacySlashCommandAdapter = __esm({
         };
         this.handler.register(newCommand);
       }
+      /**
+       * Register essential commands that should be available in legacy sessions
+       */
+      registerEssentialCommands() {
+        try {
+          const helpCommand = new HelpCommandV2();
+          const helpCommandV2 = {
+            name: "help",
+            aliases: ["h", "?"],
+            description: helpCommand.description,
+            category: helpCommand.category,
+            execute: async (context2) => {
+              try {
+                const result = await helpCommand.execute({
+                  raw: context2.args?.join(" ") || "",
+                  parsed: {
+                    positional: context2.args || [],
+                    named: {},
+                    flags: {}
+                  },
+                  options: {},
+                  flags: {}
+                }, context2);
+                return {
+                  success: result.success,
+                  messages: [{ role: "assistant", content: result.message || result.data || "" }],
+                  error: result.error
+                };
+              } catch (error) {
+                return {
+                  success: false,
+                  error: error instanceof Error ? error.message : "Help command failed",
+                  messages: []
+                };
+              }
+            }
+          };
+          this.handler.register(helpCommandV2);
+        } catch (error) {
+          console.warn("Failed to register essential commands:", error);
+        }
+      }
       /**
        * Get the underlying SlashCommandHandlerV2 instance
        */
@@ -11000,10 +12747,10 @@ var init_interactive_cli = __esm({
         this.selectedIndex = 0;
         this.isShowingSuggestions = false;
         process.stdout.write(prompt);
-        return new Promise((resolve2) => {
+        return new Promise((resolve4) => {
           const handler = (input4) => {
             this.rl.removeListener("line", handler);
-            resolve2(input4);
+            resolve4(input4);
           };
           this.rl.on("line", handler);
         });
@@ -11038,8 +12785,8 @@ var init_interactive_cli = __esm({
   }
 });
 function loadEnvironmentVariables() {
-  const _envPath = path6__namespace.join(process.cwd(), ".env");
-  if (fs4__namespace.existsSync(_envPath)) {
+  const _envPath = path8__namespace.join(process.cwd(), ".env");
+  if (fs6__namespace.existsSync(_envPath)) {
     const _result = dotenv__namespace.config({ path: _envPath });
     if (_result.error) {
       console.warn("Error loading .env:", _result.error);
@@ -11047,8 +12794,8 @@ function loadEnvironmentVariables() {
       console.log("\u2705 Loaded environment from .env");
     }
   }
-  const _lmstudioEnvPath = path6__namespace.join(process.cwd(), ".env.lmstudio");
-  if (fs4__namespace.existsSync(_lmstudioEnvPath)) {
+  const _lmstudioEnvPath = path8__namespace.join(process.cwd(), ".env.lmstudio");
+  if (fs6__namespace.existsSync(_lmstudioEnvPath)) {
     const _result = dotenv__namespace.config({ path: _lmstudioEnvPath, override: false });
     if (_result.error) {
       console.warn("Error loading .env.lmstudio:", _result.error);
@@ -11079,25 +12826,25 @@ function getPackageJson() {
   try {
     const possiblePaths = [
       // When running from built dist/
-      path6.join(__dirname, "../../package.json"),
+      path8.join(__dirname, "../../package.json"),
       // When running from source
-      path6.join(__dirname, "../../../package.json"),
+      path8.join(__dirname, "../../../package.json"),
       // Current working directory
-      path6.join(process.cwd(), "package.json"),
+      path8.join(process.cwd(), "package.json"),
       // One level up from current working directory
-      path6.join(process.cwd(), "../package.json"),
+      path8.join(process.cwd(), "../package.json"),
       // For globally installed packages
-      path6.join(__dirname, "../../../../package.json"),
-      path6.join(__dirname, "../../../../../package.json"),
+      path8.join(__dirname, "../../../../package.json"),
+      path8.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
-      path6.join(
+      path8.join(
         process.env.HOME || "",
         ".npm-global/lib/node_modules/@bonginkan/maria/package.json"
       ),
-      path6.join(
+      path8.join(
         process.env.HOME || "",
         ".nvm/versions/node",
         process.version,
@@ -11105,13 +12852,13 @@ function getPackageJson() {
       )
     ];
     let packageJsonPath = null;
-    for (const path7 of possiblePaths) {
-      if (fs4.existsSync(path7)) {
+    for (const path9 of possiblePaths) {
+      if (fs6.existsSync(path9)) {
         try {
-          const content = fs4.readFileSync(path7, "utf-8");
+          const content = fs6.readFileSync(path9, "utf-8");
           const parsed = JSON.parse(content);
           if (parsed.name === "@bonginkan/maria") {
-            packageJsonPath = path7;
+            packageJsonPath = path9;
             break;
           }
         } catch {
@@ -11122,7 +12869,7 @@ function getPackageJson() {
     if (!packageJsonPath) {
       throw new Error("package.json not found in any expected location");
     }
-    const packageJsonContent = fs4.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonContent = fs6.readFileSync(packageJsonPath, "utf-8");
     _cachedPackageJson = JSON.parse(packageJsonContent);
     return _cachedPackageJson;
   } catch (error) {
@@ -11137,121 +12884,6 @@ var init_version = __esm({
     getVersion();
   }
 });
-var LogLevel, Logger, logger, envLogLevel;
-var init_logger = __esm({
-  "src/utils/logger.ts"() {
-    LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-      LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
-      LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
-      LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
-      LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
-      LogLevel2[LogLevel2["NONE"] = 4] = "NONE";
-      return LogLevel2;
-    })(LogLevel || {});
-    Logger = class {
-      level = 2 /* WARN */;
-      // Default to WARN to reduce noise
-      prefix = "[MARIA CODE]";
-      setLevel(level) {
-        this.level = level;
-      }
-      debug(...args) {
-        if (this.level <= 0 /* DEBUG */) {
-          console.log(chalk13__default.default.magenta(`${this.prefix} [DEBUG]`), ...args);
-        }
-      }
-      info(...args) {
-        if (this.level <= 1 /* INFO */) {
-          console.log(chalk13__default.default.bold.magenta(`${this.prefix} [INFO]`), ...args);
-        }
-      }
-      warn(...args) {
-        if (this.level <= 2 /* WARN */) {
-          console.warn(chalk13__default.default.bold.magenta(`${this.prefix} [WARN]`), ...args);
-        }
-      }
-      error(...args) {
-        if (this.level <= 3 /* ERROR */) {
-          console.error(chalk13__default.default.bold.magenta(`${this.prefix} [ERROR]`), ...args);
-        }
-      }
-      success(...args) {
-        if (this.level <= 1 /* INFO */) {
-          console.log(chalk13__default.default.bold.magenta(`${this.prefix} [SUCCESS]`), ...args);
-        }
-      }
-      task(taskName, status, message) {
-        if (this.level > 1 /* INFO */) {
-          return;
-        }
-        const statusIcons = {
-          start: "\u{1F680}",
-          progress: "\u23F3",
-          complete: "\u2705",
-          error: "\u274C"
-        };
-        const statusColors = {
-          start: chalk13__default.default.bold.magenta,
-          progress: chalk13__default.default.magenta,
-          complete: chalk13__default.default.bold.magenta,
-          error: chalk13__default.default.bold.magenta
-        };
-        const icon = statusIcons[status];
-        const color = statusColors[status];
-        const formattedMessage = message ? `: ${message}` : "";
-        console.log(color(`${this.prefix} ${icon} ${taskName}${formattedMessage}`));
-      }
-      table(data2) {
-        if (this.level > 1 /* INFO */) {
-          return;
-        }
-        console.table(data2);
-      }
-      json(obj, pretty = true) {
-        if (this.level > 0 /* DEBUG */) {
-          return;
-        }
-        console.log(chalk13__default.default.magenta(`${this.prefix} [JSON]`));
-        console.log(pretty ? JSON.stringify(obj, null, 2) : JSON.stringify(obj));
-      }
-      divider() {
-        if (this.level > 1 /* INFO */) {
-          return;
-        }
-        console.log(chalk13__default.default.magenta("\u2500".repeat(60)));
-      }
-      clear() {
-        console.clear();
-      }
-      /**
-       * プログレスバーを表示
-       */
-      progress(current, total, label) {
-        if (this.level > 1 /* INFO */) {
-          return;
-        }
-        const percentage = Math.round(current / total * 100);
-        const barLength = 30;
-        const filled = Math.round(percentage / 100 * barLength);
-        const empty = barLength - filled;
-        const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
-        const progressText = `${current}/${total}`;
-        const labelText = label ? ` ${label}` : "";
-        process.stdout.write(
-          `\r${chalk13__default.default.bold.magenta(bar)} ${percentage}% ${progressText}${labelText}`
-        );
-        if (current === total) {
-          process.stdout.write("\n");
-        }
-      }
-    };
-    logger = new Logger();
-    envLogLevel = process.env["MARIA_LOG_LEVEL"]?.toUpperCase();
-    if (envLogLevel && LogLevel[envLogLevel] !== void 0) {
-      logger.setLevel(LogLevel[envLogLevel]);
-    }
-  }
-});
 
 // src/providers/ai-provider.ts
 var BaseAIProvider;
@@ -11797,7 +13429,7 @@ var init_lmstudio_provider = __esm({
               throw _error;
             }
             await new Promise(
-              (resolve2) => setTimeout(resolve2, this.retryDelay * Math.pow(2, i2))
+              (resolve4) => setTimeout(resolve4, this.retryDelay * Math.pow(2, i2))
             );
           }
         }
@@ -12708,23 +14340,23 @@ var init_default_provider = __esm({
 function loadConfig() {
   let currentDir = process.cwd();
   while (currentDir !== "/") {
-    const _configPath = path6.join(currentDir, _CONFIG_FILE);
-    if (fs4.existsSync(_configPath)) {
+    const _configPath = path8.join(currentDir, _CONFIG_FILE);
+    if (fs6.existsSync(_configPath)) {
       try {
-        const _content = fs4.readFileSync(_configPath, "utf-8");
+        const _content = fs6.readFileSync(_configPath, "utf-8");
         return toml.parse(_content);
       } catch {
       }
     }
-    const _parentDir = path6.join(currentDir, "..");
+    const _parentDir = path8.join(currentDir, "..");
     if (_parentDir === currentDir) {
       break;
     }
     currentDir = _parentDir;
   }
-  if (fs4.existsSync(_GLOBAL_CONFIG_PATH)) {
+  if (fs6.existsSync(_GLOBAL_CONFIG_PATH)) {
     try {
-      const _content = fs4.readFileSync(_GLOBAL_CONFIG_PATH, "utf-8");
+      const _content = fs6.readFileSync(_GLOBAL_CONFIG_PATH, "utf-8");
       return toml.parse(_content);
     } catch {
     }
@@ -12765,7 +14397,7 @@ var _CONFIG_FILE, _GLOBAL_CONFIG_PATH;
 var init_config2 = __esm({
   "src/utils/config.ts"() {
     _CONFIG_FILE = ".maria-code.toml";
-    _GLOBAL_CONFIG_PATH = path6.join(os2.homedir(), ".maria-code", "_config.toml");
+    _GLOBAL_CONFIG_PATH = path8.join(os2.homedir(), ".maria-code", "_config.toml");
   }
 });
 
@@ -13283,7 +14915,7 @@ Include: function descriptions, parameter explanations, return values, usage exa
       // Helper methods
       async detectFramework() {
         try {
-          const _packageJson = await fs6__namespace.readFile("package.json", "utf-8");
+          const _packageJson = await fs8__namespace.readFile("package.json", "utf-8");
           const _pkg = JSON.parse(_packageJson);
           if (_pkg.dependencies?.react || _pkg.devDependencies?.react) {
             return "React";
@@ -13309,7 +14941,7 @@ Include: function descriptions, parameter explanations, return values, usage exa
       }
       async detectProjectType() {
         try {
-          const _files = await fs6__namespace.readdir(process.cwd());
+          const _files = await fs8__namespace.readdir(process.cwd());
           if (_files.includes("package.json")) {
             return "Node.js";
           }
@@ -13332,7 +14964,7 @@ Include: function descriptions, parameter explanations, return values, usage exa
       async detectTestFramework(_context) {
         if (_context.language === "javascript" || _context.language === "typescript") {
           try {
-            const _packageJson = await fs6__namespace.readFile("package.json", "utf-8");
+            const _packageJson = await fs8__namespace.readFile("package.json", "utf-8");
             const _pkg = JSON.parse(_packageJson);
             if (_pkg.devDependencies?.jest) {
               return "Jest";
@@ -13379,7 +15011,7 @@ Include: function descriptions, parameter explanations, return values, usage exa
     };
     LanguageDetector = class {
       async detectFromFile(_filePath) {
-        const _ext = path6__namespace.extname(_filePath).toLowerCase();
+        const _ext = path8__namespace.extname(_filePath).toLowerCase();
         const languageMap = {
           ".js": "javascript",
           ".jsx": "javascript",
@@ -13848,21 +15480,21 @@ var init_llm_health_checker = __esm({
       }
       async startLMStudio() {
         try {
-          const { spawn } = await import('child_process');
+          const { spawn: spawn2 } = await import('child_process');
           const _lmsPath = "/Users/bongin_max/.lmstudio/bin/lms";
-          return new Promise((resolve2) => {
-            const _child = spawn(_lmsPath, ["server", "start"], {
+          return new Promise((resolve4) => {
+            const _child = spawn2(_lmsPath, ["server", "start"], {
               stdio: "ignore",
               detached: true
             });
             child.on("_error", () => {
-              resolve2(false);
+              resolve4(false);
             });
             _child.on("spawn", () => {
               child.unref();
               setTimeout(async () => {
                 const _status = await this.checkService("LM Studio");
-                resolve2(_status.isRunning);
+                resolve4(_status.isRunning);
               }, 3e3);
             });
           });
@@ -13876,18 +15508,15 @@ var init_llm_health_checker = __esm({
 var ProviderSelector;
 var init_provider_selector = __esm({
   "src/services/provider-selector.ts"() {
-    init_providers();
     ProviderSelector = class {
       config;
-      modernProviderManager;
-      legacyProviderManager;
+      providerManager;
       constructor(_config) {
         this.config = _config;
-        this.modernProviderManager = new UnifiedAIProviderManager();
-        this.legacyProviderManager = new UnifiedAIProviderManager2(_config);
+        this.providerManager = new UnifiedAIProviderManager();
       }
       async initialize() {
-        await this.modernProviderManager.initialize();
+        await this.providerManager.initialize();
       }
       async selectProvider() {
         const providers = await this.getAvailableProviders();
@@ -17601,12 +19230,12 @@ var init_errors = __esm({
 });
 
 // src/services/interactive-session/core/SessionManager.ts
-var SessionManager2;
+var SessionManager;
 var init_SessionManager = __esm({
   "src/services/interactive-session/core/SessionManager.ts"() {
     init_SessionStateMachine();
     init_errors();
-    SessionManager2 = class {
+    SessionManager = class {
       constructor(input4, display, command, options = {}) {
         this.input = input4;
         this.display = display;
@@ -17851,11 +19480,11 @@ var init_InputController = __esm({
         try {
           this.enableRawMode(true);
           await this.installKeypress();
-          const line = await new Promise((resolve2) => {
+          const line = await new Promise((resolve4) => {
             const onKey = (str, key2) => {
               if (key2?.name === "escape" && this.opts.escCancels)
-                return resolve2(null);
-              if (key2?.ctrl && key2?.name === "c") return resolve2(null);
+                return resolve4(null);
+              if (key2?.ctrl && key2?.name === "c") return resolve4(null);
               if (key2?.name === "return" || key2?.name === "enter") {
                 return;
               }
@@ -17864,7 +19493,7 @@ var init_InputController = __esm({
             process$1.stdin.on("keypress", onKey);
             this.rl.question("", (answer) => {
               process$1.stdin.off("keypress", onKey);
-              resolve2(answer.trim());
+              resolve4(answer.trim());
             });
           });
           this.lastSubmitAt = Date.now();
@@ -17913,11 +19542,11 @@ var init_InputController = __esm({
     };
   }
 });
-var ReadlineAdapter2;
+var ReadlineAdapter;
 var init_ReadlineAdapter = __esm({
   "src/services/interactive-session/adapters/ReadlineAdapter.ts"() {
     init_InputController();
-    ReadlineAdapter2 = class {
+    ReadlineAdapter = class {
       rl;
       inputController;
       constructor() {
@@ -17933,10 +19562,10 @@ var init_ReadlineAdapter = __esm({
       }
       async readline(signal) {
         if (signal?.aborted) return null;
-        return new Promise((resolve2) => {
-          const abortHandler = () => resolve2(null);
+        return new Promise((resolve4) => {
+          const abortHandler = () => resolve4(null);
           signal?.addEventListener("abort", abortHandler, { once: true });
-          this.inputController.readline().then(resolve2).catch(() => resolve2(null)).finally(() => {
+          this.inputController.readline().then(resolve4).catch(() => resolve4(null)).finally(() => {
             signal?.removeEventListener("abort", abortHandler);
           });
         });
@@ -17962,10 +19591,10 @@ var init_ReadlineAdapter = __esm({
     };
   }
 });
-var ChalkAdapter2;
+var ChalkAdapter;
 var init_ChalkAdapter = __esm({
   "src/services/interactive-session/adapters/ChalkAdapter.ts"() {
-    ChalkAdapter2 = class {
+    ChalkAdapter = class {
       spinners = /* @__PURE__ */ new Map();
       spinnerId = 0;
       async showWelcome() {
@@ -20398,11 +22027,11 @@ var init_ConfigService = __esm({
       _saveDebounceTimer = null;
       _isDirty = false;
       constructor(configDir = process.env.MARIA_CONFIG_DIR || "~/.maria") {
-        this._configPath = path6__namespace.join(
+        this._configPath = path8__namespace.join(
           this.expandHome(configDir),
           "session.config.json"
         );
-        this._userConfigPath = path6__namespace.join(
+        this._userConfigPath = path8__namespace.join(
           this.expandHome(configDir),
           "user.config.json"
         );
@@ -20423,7 +22052,7 @@ var init_ConfigService = __esm({
        */
       async loadSystemConfig() {
         try {
-          const configFile = await fs6__namespace.readFile(this._configPath, "utf-8");
+          const configFile = await fs8__namespace.readFile(this._configPath, "utf-8");
           return JSON.parse(configFile);
         } catch (error) {
           return {};
@@ -20434,7 +22063,7 @@ var init_ConfigService = __esm({
        */
       async loadUserConfig() {
         try {
-          const configFile = await fs6__namespace.readFile(this._userConfigPath, "utf-8");
+          const configFile = await fs8__namespace.readFile(this._userConfigPath, "utf-8");
           return JSON.parse(configFile);
         } catch (error) {
           return {};
@@ -20477,8 +22106,8 @@ var init_ConfigService = __esm({
       /**
        * ネストされた設定値の取得
        */
-      getNestedValue(path7) {
-        const keys = path7.split(".");
+      getNestedValue(path9) {
+        const keys = path9.split(".");
         let value = this._config;
         for (const key2 of keys) {
           if (value && typeof value === "object" && key2 in value) {
@@ -20508,8 +22137,8 @@ var init_ConfigService = __esm({
       /**
        * ネストされた設定値の更新
        */
-      async setNestedValue(path7, value) {
-        const keys = path7.split(".");
+      async setNestedValue(path9, value) {
+        const keys = path9.split(".");
         const lastKey = keys.pop();
         let target = this._config;
         for (const key2 of keys) {
@@ -20522,7 +22151,7 @@ var init_ConfigService = __esm({
         target[lastKey] = value;
         this.validateConfig();
         this.emitChange({
-          path: path7,
+          path: path9,
           oldValue,
           newValue: value,
           timestamp: /* @__PURE__ */ new Date()
@@ -20536,9 +22165,9 @@ var init_ConfigService = __esm({
       async save() {
         if (!this._isDirty) return;
         try {
-          const configDir = path6__namespace.dirname(this._userConfigPath);
-          await fs6__namespace.mkdir(configDir, { recursive: true });
-          await fs6__namespace.writeFile(
+          const configDir = path8__namespace.dirname(this._userConfigPath);
+          await fs8__namespace.mkdir(configDir, { recursive: true });
+          await fs8__namespace.writeFile(
             this._userConfigPath,
             JSON.stringify(this._config, null, 2),
             "utf-8"
@@ -20567,8 +22196,8 @@ var init_ConfigService = __esm({
       setupAutoSave() {
         process.on("exit", () => {
           if (this._isDirty) {
-            const fs7 = __require("fs");
-            fs7.writeFileSync(
+            const fs9 = __require("fs");
+            fs9.writeFileSync(
               this._userConfigPath,
               JSON.stringify(this._config, null, 2),
               "utf-8"
@@ -20579,13 +22208,13 @@ var init_ConfigService = __esm({
       /**
        * 変更リスナーの登録
        */
-      onChange(path7, listener) {
-        if (!this._listeners.has(path7)) {
-          this._listeners.set(path7, []);
+      onChange(path9, listener) {
+        if (!this._listeners.has(path9)) {
+          this._listeners.set(path9, []);
         }
-        this._listeners.get(path7).push(listener);
+        this._listeners.get(path9).push(listener);
         return () => {
-          const listeners = this._listeners.get(path7);
+          const listeners = this._listeners.get(path9);
           if (listeners) {
             const index = listeners.indexOf(listener);
             if (index !== -1) {
@@ -20615,7 +22244,7 @@ var init_ConfigService = __esm({
        * 設定のエクスポート
        */
       async export(filePath) {
-        await fs6__namespace.writeFile(
+        await fs8__namespace.writeFile(
           filePath,
           JSON.stringify(this._config, null, 2),
           "utf-8"
@@ -20625,7 +22254,7 @@ var init_ConfigService = __esm({
        * 設定のインポート
        */
       async import(filePath) {
-        const configFile = await fs6__namespace.readFile(filePath, "utf-8");
+        const configFile = await fs8__namespace.readFile(filePath, "utf-8");
         const importedConfig = JSON.parse(configFile);
         this._config = SessionConfigSchema.parse(importedConfig);
         this._isDirty = true;
@@ -20636,7 +22265,7 @@ var init_ConfigService = __esm({
        */
       expandHome(filePath) {
         if (filePath.startsWith("~/")) {
-          return path6__namespace.join(process.env.HOME || "", filePath.slice(2));
+          return path8__namespace.join(process.env.HOME || "", filePath.slice(2));
         }
         return filePath;
       }
@@ -21074,7 +22703,7 @@ var init_ValidationService = __esm({
         );
         this._schemas.set(
           "filePath",
-          zod.z.string().min(1).max(this._config.maxFilePathLength).refine((path7) => !this.containsPathTraversal(path7), {
+          zod.z.string().min(1).max(this._config.maxFilePathLength).refine((path9) => !this.containsPathTraversal(path9), {
             message: "Path traversal detected"
           })
         );
@@ -21213,11 +22842,11 @@ var init_ValidationService = __esm({
       /**
        * ファイルパス検証
        */
-      validateFilePath(path7) {
+      validateFilePath(path9) {
         try {
           const schema = this._schemas.get("filePath");
-          const result = schema.parse(path7);
-          if (this.isSystemPath(path7)) {
+          const result = schema.parse(path9);
+          if (this.isSystemPath(path9)) {
             return {
               valid: false,
               errors: [
@@ -21363,8 +22992,8 @@ var init_ValidationService = __esm({
       /**
        * パストラバーサルの検出
        */
-      containsPathTraversal(path7) {
-        return /\.\.[/\\]/.test(path7) || path7.includes("..\\") || path7.includes("../");
+      containsPathTraversal(path9) {
+        return /\.\.[/\\]/.test(path9) || path9.includes("..\\") || path9.includes("../");
       }
       /**
        * 危険なコマンドの判定
@@ -21391,7 +23020,7 @@ var init_ValidationService = __esm({
       /**
        * システムパスの判定
        */
-      isSystemPath(path7) {
+      isSystemPath(path9) {
         const systemPaths = [
           "/etc",
           "/sys",
@@ -21405,7 +23034,7 @@ var init_ValidationService = __esm({
           "/sbin"
         ];
         return systemPaths.some(
-          (sysPath) => path7.toLowerCase().startsWith(sysPath.toLowerCase())
+          (sysPath) => path9.toLowerCase().startsWith(sysPath.toLowerCase())
         );
       }
       /**
@@ -22829,20 +24458,20 @@ var init_ApprovalEngine = __esm({
           );
           this.pendingRequests.set(_request.id, _request);
           this.emit("approval-requested", _request);
-          return new Promise((resolve2) => {
+          return new Promise((resolve4) => {
             if (this.config.autoApprovalTimeout > 0 && _riskAssessment.overallRisk === "low") {
               setTimeout(() => {
                 if (this.pendingRequests.has(_request.id)) {
                   this.pendingRequests.delete(_request.id);
                   this.emit("approval-timeout", { requestId: _request.id });
-                  resolve2(this.createAutoApprovalResponse("Timeout auto-approval"));
+                  resolve4(this.createAutoApprovalResponse("Timeout auto-approval"));
                 }
               }, this.config.autoApprovalTimeout);
             }
             this.once(
               `approval-response-${_request.id}`,
               (_response) => {
-                resolve2(_response);
+                resolve4(_response);
               }
             );
           });
@@ -24719,7 +26348,7 @@ var init_DisplayManager = __esm({
         for (const frame of frames) {
           this.clearLine();
           this.write(frame);
-          await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+          await new Promise((resolve4) => setTimeout(resolve4, intervalMs));
         }
         this.writeLine();
       }
@@ -26048,8 +27677,8 @@ var init_SessionOrchestrator = __esm({
        * UIサービスの初期化
        */
       async initializeUIServices() {
-        this._readlineAdapter = new ReadlineAdapter2();
-        this._chalkAdapter = new ChalkAdapter2();
+        this._readlineAdapter = new ReadlineAdapter();
+        this._chalkAdapter = new ChalkAdapter();
         this._displayManager = new DisplayManager();
         this._spinnerManager = SpinnerManager.getInstance();
         this._statusDisplay = new StatusDisplay();
@@ -26128,7 +27757,7 @@ var init_SessionOrchestrator = __esm({
         if (!this._inputController || !this._displayManager || !this._commandRegistry || !this._stateMachine) {
           throw new Error("Required components not initialized");
         }
-        this._sessionManager = new SessionManager2(
+        this._sessionManager = new SessionManager(
           this._inputController,
           this._displayManager,
           this._commandRegistry,
@@ -26212,15 +27841,15 @@ var init_SessionOrchestrator = __esm({
       /**
        * 設定の取得
        */
-      getConfig(path7) {
-        return this._configService?.getNestedValue(path7);
+      getConfig(path9) {
+        return this._configService?.getNestedValue(path9);
       }
       /**
        * 設定の更新
        */
-      async setConfig(path7, value) {
+      async setConfig(path9, value) {
         if (this._configService) {
-          await this._configService.setNestedValue(path7, value);
+          await this._configService.setNestedValue(path9, value);
         }
       }
       /**
@@ -26315,91 +27944,11 @@ function createInteractiveSession(maria, config2) {
   const orchestrator = new SessionOrchestrator(context2, config2);
   return new RefactoredInteractiveSession(orchestrator);
 }
-var CommandAdapter, RefactoredInteractiveSession;
+var RefactoredInteractiveSession;
 var init_interactive_session = __esm({
   "src/services/interactive-session/index.ts"() {
     init_SessionOrchestrator();
     init_errors();
-    CommandAdapter = class {
-      constructor(maria) {
-        this.maria = maria;
-      }
-      async execute(command, context2) {
-        try {
-          switch (command) {
-            case "/help":
-              return {
-                ok: true,
-                message: `\u{1F4D6} Available Commands:
-\u2022 /help - Show this help message
-\u2022 /clear - Clear the context
-\u2022 /status - Show system status
-\u2022 /model - Manage AI models
-\u2022 /code - Generate code
-\u2022 /exit - Exit the session`
-              };
-            case "/clear":
-              return {
-                ok: true,
-                message: "\u{1F9F9} Context cleared"
-              };
-            case "/status":
-              return {
-                ok: true,
-                message: "\u2705 System is operational"
-              };
-            default:
-              return {
-                ok: false,
-                message: `Command ${command} is being migrated to the new system`
-              };
-          }
-        } catch (error) {
-          return {
-            ok: false,
-            message: `Error executing command: ${error}`
-          };
-        }
-      }
-      exists(command) {
-        const knownCommands = [
-          "/help",
-          "/clear",
-          "/status",
-          "/model",
-          "/code",
-          "/exit",
-          "/memory",
-          "/test",
-          "/review"
-        ];
-        return knownCommands.includes(command.toLowerCase());
-      }
-      getAvailableCommands() {
-        return [
-          "/help",
-          "/clear",
-          "/status",
-          "/model",
-          "/code",
-          "/exit",
-          "/memory",
-          "/test",
-          "/review"
-        ];
-      }
-      getHelp(command) {
-        const helpTexts = {
-          "/help": "Show available commands",
-          "/clear": "Clear the conversation context",
-          "/status": "Show system status",
-          "/model": "Select or view AI models",
-          "/code": "Generate code from a description",
-          "/exit": "Exit the session"
-        };
-        return helpTexts[command.toLowerCase()] || null;
-      }
-    };
     RefactoredInteractiveSession = class {
       orchestrator;
       constructor(orchestrator) {
@@ -26418,20 +27967,13 @@ var init_interactive_session = __esm({
       getStats() {
         return this.orchestrator.getSessionStats();
       }
-      getConfig(path7) {
-        return this.orchestrator.getConfig(path7);
+      getConfig(path9) {
+        return this.orchestrator.getConfig(path9);
       }
-      async setConfig(path7, value) {
-        await this.orchestrator.setConfig(path7, value);
+      async setConfig(path9, value) {
+        await this.orchestrator.setConfig(path9, value);
       }
     };
-    ({
-      SessionManager,
-      ReadlineAdapter,
-      ChalkAdapter,
-      CommandAdapter,
-      SessionOrchestrator
-    });
   }
 });
 
@@ -26441,7 +27983,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@bonginkan/maria",
-      version: "3.6.3",
+      version: "3.6.4",
       description: "\u{1F680} MARIA v3.6.0 - Premier Enterprise AI Development Platform. Revolutionary multimodal intelligence featuring advanced orchestration, production-grade telemetry, and sophisticated workflow templates. Delivers 93% performance enhancement with real-time TUI monitoring, ML-powered model selection, quantum-resistant security architecture, and comprehensive observability. Battle-tested for enterprise deployment with exceptional reliability.",
       keywords: [
         "ai",
@@ -27024,7 +28566,7 @@ async function generateAIResponse(userInput) {
 }
 async function streamAIResponse(userInput) {
   const thinkingInterval = startThinkingAnimation();
-  await new Promise((resolve2) => setTimeout(resolve2, 200));
+  await new Promise((resolve4) => setTimeout(resolve4, 200));
   clearInterval(thinkingInterval);
   process.stdout.write("\r" + " ".repeat(50) + "\r");
   const response2 = await generateAIResponse(userInput);
@@ -27197,6 +28739,36 @@ async function startInteractiveSession() {
               // wrapped for reference safety
             }))
           };
+          if (command === "/help" || command === "help") {
+            console.log(`
+\u{1F4D6} MARIA Commands (Basic Help)
+
+\u{1F680} Core Commands:
+   /help    - Show this help message
+   /clear   - Clear conversation context  
+   /exit    - Exit MARIA
+   /status  - Show system status
+   /config  - Show configuration
+   /model   - Select AI model
+
+\u{1F3A8} Generation:
+   /code    - Generate/fix code
+   /test    - Generate tests
+   /review  - Review code
+
+For full help, run: pnpm build and check documentation.
+            `);
+            continue;
+          }
+          if (command === "/code" || command === "code") {
+            if (args.length === 0) {
+              console.log("\u274C Please provide a code request. Example: /code create a REST API");
+              continue;
+            }
+            console.log("\u{1F680} Processing code request...");
+            console.log("\u26A0\uFE0F  Note: /code command functionality is being restored. Please try the legacy command system or check back after further updates.");
+            continue;
+          }
           try {
             const result = await slashCommandHandler.handleCommand(
               command,
@@ -27284,6 +28856,7 @@ async function startInteractiveSession() {
 function createCLI2() {
   const program2 = new commander.Command();
   program2.name("maria").description(`\u{1F680} MARIA v${packageJson.version} - Intelligent AI Assistant`).version(packageJson.version).option("--v3-session", "Use v3 session architecture").option("--no-interactive", "Disable interactive mode for CI/CD").action(async (options) => {
+    loadEnvironmentVariables();
     const { displayFinalStartupScreen: displayFinalStartupScreen2 } = await Promise.resolve().then(() => (init_startup_display(), startup_display_exports));
     displayFinalStartupScreen2();
     const useV3 = options.v3Session || process.env.MARIA_USE_V3_SESSION === "1";