@bonginkan/maria 3.0.9 → 3.1.0

package/dist/cli.cjs

@@ -59,9 +59,7 @@ var inquirer__default = /*#__PURE__*/_interopDefault(inquirer);
 var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a2, b) => (typeof require !== "undefined" ? require : a2)[b]
 }) : x)(function(x) {
@@ -75,15 +73,6 @@ var __export = (target2, all) => {
   for (var name2 in all)
     __defProp(target2, name2, { get: all[name2], enumerable: true });
 };
-var __copyProps = (to, from, except, desc2) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key2 of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key2) && key2 !== except)
-        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc2 = __getOwnPropDesc(from, key2)) || desc2.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ConversationPersistence;
 var init_conversation_persistence = __esm({
   "src/services/conversation-persistence.ts"() {
@@ -454,14 +443,7 @@ var init_ai_response_service = __esm({
       async callAIProvider(context2, _options) {
         const userInput2 = context2.currentInput.toLowerCase();
         const hasContext = context2.messages.length > 0;
-        console.log("\u{1F9E0} AI Provider Debug:", {
-          userInput: userInput2,
-          hasContext,
-          messagesCount: context2.messages.length,
-          contextStats: context2.contextStats
-        });
         const intent2 = this.analyzeIntent(userInput2, context2);
-        console.log("\u{1F3AF} Intent Analysis:", intent2);
         switch (intent2.type) {
           case "TETRIS_REQUEST":
             return this.generateTetrisGame(userInput2);
@@ -485,11 +467,6 @@ var init_ai_response_service = __esm({
         const messages2 = context2.messages || [];
         const recentMessages2 = messages2.slice(-3);
         const contextString = recentMessages2.map((m) => m.content).join(" ").toLowerCase();
-        console.log("\u{1F50D} Context Analysis:", {
-          userInput: userInput2,
-          contextString: contextString.substring(0, 100) + "...",
-          recentMessagesCount: recentMessages2.length
-        });
         if (userInput2.includes("tetris") || contextString.includes("tetris") && (userInput2.includes("html") || userInput2.includes("game") || userInput2.includes("whole code") || userInput2.includes("start") || userInput2.includes("black") || userInput2.includes("background"))) {
           return {
             type: "TETRIS_REQUEST",
@@ -3782,522 +3759,856 @@ var init_template_manager = __esm({
     };
   }
 });
-var logger4, HotkeyManager;
-var init_hotkey_manager = __esm({
-  "src/services/hotkey-manager.ts"() {
-    init_slash_command_handler();
-    init_logger();
-    logger4 = logger;
-    HotkeyManager = class _HotkeyManager {
+var BatchExecutionEngine;
+var init_batch_execution = __esm({
+  "src/services/batch-execution.ts"() {
+    BatchExecutionEngine = class _BatchExecutionEngine {
       static instance;
-      _bindings = /* @__PURE__ */ new Map();
       commandHandler = null;
-      configPath;
-      isEnabled = true;
-      // private activeKeys: Set<string> = new Set(); // Reserved for future use
-      /**
-       * Normalize binding to handle both underscored and plain keys
-       */
-      normalize(b) {
-        const key2 = b.key ?? b._key;
-        const modifiers = b.modifiers ?? b._modifiers ?? [];
-        const command = b.command ?? b._command;
-        const args2 = b.args ?? b._args;
-        const description2 = b.description;
-        const enabled = b.enabled ?? true;
-        return { key: key2, modifiers, command, args: args2, description: description2, enabled };
-      }
-      /**
-       * Convert old config format to new format
-       */
-      coerceConfig(raw) {
-        if (!raw || typeof raw !== "object") return null;
-        const list = Array.isArray(raw.bindings) ? raw.bindings : Array.isArray(raw._bindings) ? raw._bindings : [];
-        const bindings2 = list.map((r) => this.normalize(r));
-        const globalEnabled = raw.globalEnabled ?? true;
-        return { bindings: bindings2, globalEnabled };
+      variables = {};
+      isExecuting = false;
+      constructor() {
       }
       /**
-       * Generate binding key from normalized object
+       * Set command handler via dependency injection
        */
-      getBindingKeyFromNormalized(n2) {
-        const mods = [...n2.modifiers ?? []].sort().join("+");
-        return mods ? `${mods}+${n2.key}` : n2.key;
-      }
-      constructor() {
-        this.configPath = path17.join(os2.homedir(), ".maria", "hotkeys.json");
-        this.loadBindings();
-        this.initializeDefaultBindings();
+      setCommandHandler(handler) {
+        this.commandHandler = handler;
       }
       getCommandHandler() {
         if (!this.commandHandler) {
-          this.commandHandler = SlashCommandHandler.getInstance();
+          throw new Error("CommandHandler not injected. Call setCommandHandler() first.");
         }
         return this.commandHandler;
       }
       static getInstance() {
-        if (!_HotkeyManager.instance) {
-          _HotkeyManager.instance = new _HotkeyManager();
+        if (!_BatchExecutionEngine.instance) {
+          _BatchExecutionEngine.instance = new _BatchExecutionEngine();
         }
-        return _HotkeyManager.instance;
+        return _BatchExecutionEngine.instance;
       }
       /**
-       * Initialize default _hotkey _bindings
+       * Parse _batch command string
        */
-      initializeDefaultBindings() {
-        const defaults = [
-          // System shortcuts
-          {
-            key: "s",
-            modifiers: ["ctrl"],
-            command: "/_status",
-            description: "Show system _status",
-            enabled: true
-          },
-          {
-            key: "h",
-            modifiers: ["ctrl"],
-            command: "/help",
-            description: "Show help",
-            enabled: true
-          },
-          {
-            key: "l",
-            modifiers: ["ctrl"],
-            command: "/clear",
-            description: "Clear screen",
-            enabled: true
-          },
-          {
-            key: "e",
-            modifiers: ["ctrl"],
-            command: "/export",
-            args: ["--clipboard"],
-            description: "Export to clipboard",
-            enabled: true
-          },
-          {
-            key: "t",
-            modifiers: ["ctrl"],
-            command: "/test",
-            description: "Run tests",
-            enabled: true
-          },
-          {
-            key: "d",
-            modifiers: ["ctrl"],
-            command: "/doctor",
-            description: "System diagnostics",
-            enabled: true
-          },
-          {
-            key: "p",
-            modifiers: ["ctrl", "shift"],
-            command: "/pr-comments",
-            description: "Show PR comments",
-            enabled: true
-          },
-          {
-            key: "r",
-            modifiers: ["ctrl", "shift"],
-            command: "/review",
-            description: "Run PR review",
-            enabled: true
-          },
-          {
-            key: "a",
-            modifiers: ["ctrl"],
-            command: "/agents",
-            description: "Manage agents",
-            enabled: true
-          },
-          {
-            key: "m",
-            modifiers: ["ctrl"],
-            command: "/mode",
-            args: ["research"],
-            description: "Switch to research mode",
-            enabled: true
-          },
-          // Human-in-the-Loop Approval Shortcuts
-          {
-            key: "tab",
-            modifiers: ["shift"],
-            command: "/approve",
-            args: ["--quick", "--action=approve"],
-            description: "Quick approve current request (\u3044\u3044\u3088)",
-            enabled: true
-          },
-          {
-            key: "y",
-            modifiers: ["ctrl"],
-            command: "/approve",
-            args: ["--action=approve"],
-            description: "Approve current request (\u306F\u3044\u3001\u627F\u8A8D)",
-            enabled: true
-          },
-          {
-            key: "n",
-            modifiers: ["ctrl"],
-            command: "/approve",
-            args: ["--action=reject"],
-            description: "Reject current request (\u3044\u3044\u3048\u3001\u62D2\u5426)",
-            enabled: true
-          },
-          {
-            key: "t",
-            modifiers: ["ctrl", "alt"],
-            command: "/approve",
-            args: ["--action=trust"],
-            description: "Trust & auto-approve similar requests (\u4EFB\u305B\u308B)",
-            enabled: true
-          },
-          {
-            key: "r",
-            modifiers: ["ctrl"],
-            command: "/approve",
-            args: ["--action=review"],
-            description: "Request additional review (\u30EC\u30D3\u30E5\u30FC\u8981\u6C42)",
-            enabled: true
-          },
-          {
-            key: "a",
-            modifiers: ["ctrl", "shift"],
-            command: "/approve",
-            args: ["--show"],
-            description: "Show current approval request",
-            enabled: true
-          },
-          {
-            key: "q",
-            modifiers: ["ctrl"],
-            command: "/approve",
-            args: ["--queue"],
-            description: "Show approval queue",
-            enabled: true
+      parseBatchString(batchString) {
+        batchString.split("\n").filter((line) => line.trim() && !line.trim().startsWith("#"));
+        const commands2 = [];
+        lines.forEach((line) => {
+          const _ifMatch = line.match(/^IF\s+(.+)\s+THEN\s+(.+)(?:\s+ELSE\s+(.+))?$/i);
+          if (_ifMatch) {
+            const [, condition, thenCmd, elseCmd] = _ifMatch;
+            if (condition && thenCmd) {
+              commands2.push({
+                command: thenCmd.split(" ")[0] || "",
+                args: thenCmd.split(" ").slice(1),
+                condition
+              });
+              if (elseCmd) {
+                commands2.push({
+                  command: elseCmd.split(" ")[0] || "",
+                  args: elseCmd.split(" ").slice(1),
+                  condition: `!${condition}`
+                });
+              }
+            }
+            return;
           }
-        ];
-        defaults.forEach((binding) => {
-          const _key = this.getBindingKey(binding);
-          if (!this._bindings.has(_key)) {
-            this._bindings.set(_key, binding);
+          if (line.startsWith("PARALLEL:")) {
+            line.substring(9).split("&&").map((cmd2) => cmd2.trim());
+            parallelCommands.forEach((cmd2) => {
+              const _parts2 = cmd2.split(" ");
+              if (_parts2[0]) {
+                commands2.push({
+                  command: _parts2[0],
+                  args: parts.slice(1),
+                  parallel: true
+                });
+              }
+            });
+            return;
+          }
+          const _parts = line.split(" ");
+          if (_parts[0]) {
+            commands2.push({
+              command: _parts[0],
+              args: parts.slice(1)
+            });
           }
         });
+        return commands2;
       }
       /**
-       * Get unique key for binding (normalizes first)
-       */
-      getBindingKey(raw) {
-        const n2 = this.normalize(raw);
-        return this.getBindingKeyFromNormalized(n2);
-      }
-      /**
-       * Process keypress event
+       * Execute a _batch of commands
        */
-      async processKeypress(key2, context2) {
-        if (!this.isEnabled || !key2) {
-          return { handled: false };
-        }
-        const _modifiers = [];
-        const _keyObj = key2;
-        if (_keyObj.ctrl) {
-          _modifiers.push("ctrl");
-        }
-        if (_keyObj.shift) {
-          _modifiers.push("shift");
-        }
-        if (_keyObj.meta) {
-          _modifiers.push("meta");
-        }
-        if (_keyObj.alt) {
-          _modifiers.push("alt");
-        }
-        const _keyName = _keyObj.name || _keyObj.sequence;
-        if (!_keyName) {
-          return { handled: false };
+      async executeBatch(commands2, context2, options2 = {}) {
+        if (this.isExecuting) {
+          throw new Error("Batch execution already in progress");
         }
-        const _bindingKey = _modifiers.length > 0 ? `${_modifiers.sort().join("+")}+${_keyName}` : _keyName;
-        const _binding = this._bindings.get(_bindingKey);
-        if (!_binding || !_binding.enabled) {
-          return { handled: false };
+        this.isExecuting = true;
+        const _startTime = Date.now();
+        this.variables = { ...options2.variables };
+        const result2 = {
+          success: true,
+          totalCommands: commands2.length,
+          executed: 0,
+          succeeded: 0,
+          failed: 0,
+          skipped: 0,
+          _duration: 0,
+          results: [],
+          variables: this.variables
+        };
+        console.log(chalk6__default.default.blue("\n\u{1F680} Starting _batch execution\n"));
+        if (options2.dryRun) {
+          console.log(chalk6__default.default.yellow("DRY RUN MODE - Commands will not be executed\n"));
+          commands2.forEach((cmd2, _i) => {
+            console.log(chalk6__default.default.gray(`${i + 1}. ${cmd2.command} ${cmd2.args.join(" ")}`));
+            if (cmd2.condition) {
+              console.log(chalk6__default.default.gray(`   IF: ${cmd2.condition}`));
+            }
+          });
+          this.isExecuting = false;
+          return result2;
         }
         try {
-          const n2 = this.normalize(_binding);
-          logger4.info(`Hotkey triggered: ${_bindingKey} -> ${n2.command}`);
-          const _result = await this.getCommandHandler().handleCommand(
-            n2.command,
-            n2.args || [],
-            context2
-          );
-          return { handled: true, _result };
-        } catch (_error) {
-          logger4.error("Error executing _hotkey command:", _error);
-          return {
-            handled: true,
-            _result: {
-              success: false,
-              message: `Error executing _hotkey: ${_error}`
+          const _commandGroups = this.groupCommands(commands2);
+          for (const group of _commandGroups) {
+            if (options2.stopOnError && result2.failed > 0) {
+              console.log(chalk6__default.default.yellow("\n\u23F9\uFE0F  Stopping due to _error (stopOnError=true)"));
+              break;
             }
-          };
+            if (group.length === 1 && group[0]) {
+              await this.executeSingleCommand(group[0], context2, result2);
+            } else {
+              await this.executeParallelCommands(group, context2, result2, options2.maxParallel || 3);
+            }
+          }
+          result2.duration = Date.now() - _startTime;
+          result2.success = result2.failed === 0;
+          this.printSummary(result2);
+        } finally {
+          this.isExecuting = false;
         }
+        return result2;
       }
       /**
-       * Add or update _hotkey _binding
+       * Execute a single command
        */
-      addBinding(binding) {
-        const n2 = this.normalize(binding);
-        const _key = this.getBindingKeyFromNormalized(n2);
-        const _existing = this._bindings.get(_key);
-        if (_existing) {
-          const nExisting = this.normalize(_existing);
-          if (nExisting.command !== n2.command) {
-            return {
-              success: false,
-              message: `Key combination already bound to ${nExisting.command}`
-            };
+      async executeSingleCommand(cmd2, context2, result2) {
+        if (cmd2.condition && !this.evaluateCondition(cmd2.condition)) {
+          result2.skipped++;
+          console.log(chalk6__default.default.gray(`\u23ED\uFE0F  Skipping ${cmd2.command} (condition not met)`));
+          return;
+        }
+        console.log(chalk6__default.default.cyan(`
+\u25B6\uFE0F  Executing: ${cmd2.command} ${cmd2.args.join(" ")}`));
+        const _startTime = Date.now();
+        let attempts = 0;
+        const _maxAttempts = cmd2.retries ? cmd2.retries + 1 : 1;
+        while (attempts < _maxAttempts) {
+          attempts++;
+          try {
+            const _cmdResult = await this.executeWithTimeout(
+              () => this.getCommandHandler().handleCommand(cmd2.command, cmd2.args, context2),
+              cmd2.timeout || 3e4
+            );
+            const _duration = Date.now() - _startTime;
+            result2.executed++;
+            if (cmdResult.success) {
+              result2.succeeded++;
+              console.log(chalk6__default.default.green(`\u2705 Success (${_duration}ms)`));
+              result2.results.push({
+                command: `${cmd2.command} ${cmd2.args.join(" ")}`,
+                success: true,
+                output: cmdResult.message,
+                _duration
+              });
+              if (cmdResult.data && typeof cmdResult.data === "object" && "variable" in cmdResult.data && "_value" in cmdResult.data) {
+                const _resultData = cmdResult.data;
+                this.variables[resultData.variable] = resultData.value;
+              }
+              break;
+            } else {
+              if (attempts < _maxAttempts) {
+                console.log(chalk6__default.default.yellow(`\u26A0\uFE0F  Failed, retrying (${attempts}/${_maxAttempts})...`));
+                await this.delay(1e3);
+              } else {
+                result2.failed++;
+                console.log(chalk6__default.default.red(`\u274C Failed: ${cmdResult.message}`));
+                result2.results.push({
+                  command: `${cmd2.command} ${cmd2.args.join(" ")}`,
+                  success: false,
+                  _error: cmdResult.message,
+                  _duration
+                });
+              }
+            }
+          } catch (_error) {
+            const _duration = Date.now() - _startTime;
+            if (attempts < _maxAttempts) {
+              console.log(chalk6__default.default.yellow(`\u26A0\uFE0F  Error, retrying (${attempts}/${_maxAttempts})...`));
+              await this.delay(1e3);
+            } else {
+              result2.failed++;
+              result2.executed++;
+              const _errorMsg = _error instanceof Error ? error.message : "Unknown _error";
+              console.log(chalk6__default.default.red(`\u274C Error: ${_errorMsg}`));
+              result2.results.push({
+                command: `${cmd2.command} ${cmd2.args.join(" ")}`,
+                success: false,
+                _error: _errorMsg,
+                _duration
+              });
+            }
           }
         }
-        this._bindings.set(_key, {
-          key: n2.key,
-          modifiers: n2.modifiers,
-          command: n2.command,
-          args: n2.args,
-          description: n2.description,
-          enabled: n2.enabled
-        });
-        this.saveBindings();
-        return {
-          success: true,
-          message: `Hotkey ${_key} bound to ${n2.command}`
-        };
       }
       /**
-       * Remove _hotkey _binding
+       * Execute commands in parallel
        */
-      removeBinding(key2) {
-        if (!this._bindings.has(key2)) {
-          return {
-            success: false,
-            message: `No _binding found for ${key2}`
-          };
+      async executeParallelCommands(commands2, context2, result2, maxParallel) {
+        console.log(chalk6__default.default.cyan(`
+\u26A1 Executing ${commands2.length} commands in parallel`));
+        commands2.map(
+          (cmd2) => this.executeSingleCommand(cmd2, context2, {
+            ...result2,
+            executed: 0,
+            succeeded: 0,
+            failed: 0,
+            skipped: 0,
+            results: []
+          })
+        );
+        for (let i2 = 0; i2 < promises.length; i2 += maxParallel) {
+          const _batch = promises.slice(i2, i2 + maxParallel);
+          await Promise.allSettled(_batch);
+          batchResults.forEach((batchResult) => {
+            if (batchResult.status === "rejected") {
+              result2.failed++;
+              result2.executed++;
+            }
+          });
         }
-        const _binding = this._bindings.get(key2);
-        const n2 = this.normalize(_binding);
-        this._bindings.delete(key2);
-        this.saveBindings();
-        return {
-          success: true,
-          message: `Removed _hotkey ${key2} (was bound to ${n2.command})`
-        };
       }
       /**
-       * Toggle _hotkey _binding
+       * Group commands for execution
        */
-      toggleBinding(key2) {
-        const _binding = this._bindings.get(key2);
-        if (!_binding) {
-          return {
-            success: false,
-            message: `No _binding found for ${key2}`
-          };
+      groupCommands(commands2) {
+        const groups = [];
+        let currentGroup = [];
+        commands2.forEach((cmd2) => {
+          if (cmd2.parallel && currentGroup.length > 0) {
+            currentGroup.push(cmd2);
+          } else {
+            if (currentGroup.length > 0) {
+              groups.push(currentGroup);
+            }
+            currentGroup = [cmd2];
+          }
+        });
+        if (currentGroup.length > 0) {
+          groups.push(currentGroup);
         }
-        _binding.enabled = !_binding.enabled;
-        this.saveBindings();
-        return {
-          success: true,
-          message: `Hotkey ${key2} ${_binding.enabled ? "enabled" : "disabled"}`
-        };
+        return groups;
       }
       /**
-       * List all _hotkey _bindings
+       * Evaluate condition
        */
-      listBindings() {
-        const list = Array.from(this._bindings.values()).map((b) => {
-          const n2 = this.normalize(b);
-          return {
-            key: n2.key,
-            modifiers: n2.modifiers,
-            command: n2.command,
-            args: n2.args,
-            description: n2.description,
-            enabled: n2.enabled
-          };
-        });
-        return list.sort((a2, b) => {
-          const _aModCount = (a2.modifiers || []).length;
-          const _bModCount = (b.modifiers || []).length;
-          if (_aModCount !== _bModCount) return _aModCount - _bModCount;
-          return (a2.key || "").localeCompare(b.key || "");
-        });
+      evaluateCondition(condition) {
+        if (condition.startsWith("!")) {
+          return !this.evaluateCondition(condition.substring(1));
+        }
+        if (condition.startsWith("$")) {
+          const _varName = condition.substring(1);
+          return this.variables[_varName] !== void 0;
+        }
+        const _eqMatch = condition.match(/^\$(\w+)\s*==\s*(.+)$/);
+        if (_eqMatch && _eqMatch[1] && _eqMatch[2] !== void 0) {
+          const _varName = _eqMatch[1];
+          const _value = _eqMatch[2];
+          return String(this.variables[_varName] || "") === _value;
+        }
+        switch (condition) {
+          case "hasErrors":
+            return this.variables["hasErrors"] === true;
+          case "testsPass":
+            return this.variables["testsPass"] === true;
+          default:
+            return true;
+        }
       }
       /**
-       * Format _hotkey for display
+       * Execute with timeout
        */
-      formatHotkey(_binding) {
-        const n2 = this.normalize(_binding);
-        const _parts = [];
-        if (n2.modifiers.includes("ctrl")) _parts.push("Ctrl");
-        if (n2.modifiers.includes("alt")) _parts.push("Alt");
-        if (n2.modifiers.includes("shift")) _parts.push("Shift");
-        if (n2.modifiers.includes("meta")) _parts.push("Cmd/Win");
-        _parts.push(n2.key.toUpperCase());
-        return _parts.join("+");
+      async executeWithTimeout(fn, timeout) {
+        return Promise.race([
+          fn(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Command timeout")), timeout)
+          )
+        ]);
       }
       /**
-       * Parse _hotkey string
+       * Print execution summary
        */
-      parseHotkeyString(hotkeyStr) {
-        const _parts = hotkeyStr.toLowerCase().split("+").map((p) => p.trim());
-        if (_parts.length === 0) {
-          return null;
+      printSummary(result2) {
+        console.log(chalk6__default.default.blue("\n\u{1F4CA} Batch Execution Summary\n"));
+        const _successRate = result2.executed > 0 ? Math.round(result2.succeeded / result2.executed * 100) : 0;
+        console.log(`Total Commands: ${result2.totalCommands}`);
+        console.log(`Executed: ${result2.executed}`);
+        console.log(chalk6__default.default.green(`Succeeded: ${result2.succeeded}`));
+        if (result2.failed > 0) {
+          console.log(chalk6__default.default.red(`Failed: ${result2.failed}`));
         }
-        const _key = _parts[_parts.length - 1];
-        if (!_key) {
-          return null;
+        if (result2.skipped > 0) {
+          console.log(chalk6__default.default.gray(`Skipped: ${result2.skipped}`));
+        }
+        console.log(`Success Rate: ${_successRate}%`);
+        console.log(`Duration: ${(result2.duration / 1e3).toFixed(2)}s`);
+        if (Object.keys(result2.variables).length > 0) {
+          console.log("\nVariables Set:");
+          Object.entries(result2.variables).forEach(([key2, _value]) => {
+            console.log(`  ${key2} = ${JSON.stringify(_value)}`);
+          });
         }
-        const _modifiers = _parts.slice(0, -1).filter((_m) => ["ctrl", "alt", "shift", "meta", "cmd", "win"].includes(_m)).map((_m) => {
-          if (_m === "cmd" || _m === "win") {
-            return "meta";
-          }
-          return _m;
-        });
-        return { key: _key, modifiers: _modifiers };
-      }
-      /**
-       * Enable/disable hotkeys globally
-       */
-      setEnabled(enabled) {
-        this.isEnabled = enabled;
-        logger4.info(`Hotkeys ${enabled ? "enabled" : "disabled"} globally`);
       }
       /**
-       * Check if hotkeys are enabled
+       * Helper to add delay
        */
-      isHotkeysEnabled() {
-        return this.isEnabled;
+      delay(ms) {
+        return new Promise((resolve4) => setTimeout(resolve4, ms));
       }
       /**
-       * Get help text for hotkeys
+       * Check if _batch is executing
        */
-      getHelpText() {
-        const _bindings = this.listBindings().filter((b) => b.enabled);
-        if (_bindings.length === 0) {
-          return "No hotkeys configured.";
-        }
-        let help = chalk6__default.default.bold("\nAvailable Hotkeys:\n\n");
-        _bindings.forEach((raw) => {
-          const _binding = this.normalize(raw);
-          const _hotkey = chalk6__default.default.cyan(this.formatHotkey(raw));
-          const _command = chalk6__default.default.yellow(_binding.command);
-          const _args = _binding.args ? chalk6__default.default.gray(` ${_binding.args.join(" ")}`) : "";
-          const _desc = _binding.description ? chalk6__default.default.gray(` - ${_binding.description}`) : "";
-          const _status = !_binding.enabled ? chalk6__default.default.red(" [disabled]") : "";
-          help += `  ${_hotkey.padEnd(20)} \u2192 ${_command}${_args}${_desc}${_status}
-`;
-        });
-        help += `
-${chalk6__default.default.gray("Use /_hotkey to manage hotkeys")}
-`;
-        return help;
+      getExecutionStatus() {
+        return this.isExecuting;
       }
       /**
-       * Export _hotkey configuration
+       * Get current variables
        */
-      exportConfig() {
-        return {
-          bindings: this.listBindings(),
-          globalEnabled: this.isEnabled
-        };
+      getVariables() {
+        return { ...this.variables };
       }
+    };
+  }
+});
+var logger4, HotkeyManager;
+var init_hotkey_manager = __esm({
+  "src/services/hotkey-manager.ts"() {
+    init_slash_command_handler();
+    init_logger();
+    logger4 = logger;
+    HotkeyManager = class _HotkeyManager {
+      static instance;
+      _bindings = /* @__PURE__ */ new Map();
+      commandHandler = null;
+      configPath;
+      isEnabled = true;
+      // private activeKeys: Set<string> = new Set(); // Reserved for future use
       /**
-       * Import _hotkey configuration
+       * Normalize binding to handle both underscored and plain keys
        */
-      importConfig(_config) {
-        try {
-          this._bindings.clear();
-          const coerced = this.coerceConfig(_config);
-          const list = coerced ? coerced.bindings : [];
-          list.forEach((b) => {
-            const _key = this.getBindingKeyFromNormalized({ key: b.key, modifiers: b.modifiers });
-            this._bindings.set(_key, b);
-          });
-          this.isEnabled = _config.globalEnabled !== false;
-          this.saveBindings();
-          return {
-            success: true,
-            message: `Imported ${list.length} hotkey bindings`
-          };
-        } catch (_error) {
-          return {
-            success: false,
-            message: `Failed to import _config: ${_error}`
-          };
-        }
+      normalize(b) {
+        const key2 = b.key ?? b._key;
+        const modifiers = b.modifiers ?? b._modifiers ?? [];
+        const command = b.command ?? b._command;
+        const args2 = b.args ?? b._args;
+        const description2 = b.description;
+        const enabled = b.enabled ?? true;
+        return { key: key2, modifiers, command, args: args2, description: description2, enabled };
       }
       /**
-       * Load _bindings from file
+       * Convert old config format to new format
        */
-      loadBindings() {
-        try {
-          if (fs11.existsSync(this.configPath)) {
-            const _data = fs11.readFileSync(this.configPath, "utf-8");
-            const raw = JSON.parse(_data);
-            const coerced = this.coerceConfig(raw);
-            if (coerced) {
-              this.importConfig(coerced);
-            }
-          }
-        } catch (_error) {
-          logger4.warn("Failed to load _hotkey _bindings:", _error);
-        }
+      coerceConfig(raw) {
+        if (!raw || typeof raw !== "object") return null;
+        const list = Array.isArray(raw.bindings) ? raw.bindings : Array.isArray(raw._bindings) ? raw._bindings : [];
+        const bindings2 = list.map((r) => this.normalize(r));
+        const globalEnabled = raw.globalEnabled ?? true;
+        return { bindings: bindings2, globalEnabled };
       }
       /**
-       * Save _bindings to file
+       * Generate binding key from normalized object
        */
-      saveBindings() {
-        try {
-          const _config = this.exportConfig();
-          const _dir = path17.join(os2.homedir(), ".maria");
-          if (!fs11.existsSync(_dir)) {
-            fs11.mkdirSync(_dir, { recursive: true });
-          }
-          fs11.writeFileSync(this.configPath, JSON.stringify(_config, null, 2));
-        } catch (_error) {
-          logger4.error("Failed to save _hotkey _bindings:", _error);
-        }
+      getBindingKeyFromNormalized(n2) {
+        const mods = [...n2.modifiers ?? []].sort().join("+");
+        return mods ? `${mods}+${n2.key}` : n2.key;
       }
-    };
-  }
-});
-var ChatContextService2;
-var init_chat_context_service = __esm({
-  "src/services/chat-context.service.ts"() {
-    ChatContextService2 = class _ChatContextService extends events.EventEmitter {
-      static instance;
-      contextWindow = [];
-      fullHistory = [];
-      config;
-      currentTokens = 0;
-      compressionCount = 0;
-      sessionId;
-      constructor(config2) {
-        super();
-        this.config = {
-          maxTokens: config2?.maxTokens || 128e3,
-          compressionThreshold: config2?.compressionThreshold || 0.8,
-          summaryTokenLimit: config2?.summaryTokenLimit || 2e3,
-          persistPath: config2?.persistPath || path17__namespace.join(process.env["HOME"] || "", ".maria", "context")
-        };
-        this.sessionId = this.generateSessionId();
+      constructor() {
+        this.configPath = path17.join(os2.homedir(), ".maria", "hotkeys.json");
+        this.loadBindings();
+        this.initializeDefaultBindings();
       }
-      static getInstance(config2) {
-        if (!_ChatContextService.instance) {
-          _ChatContextService.instance = new _ChatContextService(config2);
+      getCommandHandler() {
+        if (!this.commandHandler) {
+          this.commandHandler = SlashCommandHandler.getInstance();
         }
-        return _ChatContextService.instance;
+        return this.commandHandler;
       }
-      generateSessionId() {
-        return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+      static getInstance() {
+        if (!_HotkeyManager.instance) {
+          _HotkeyManager.instance = new _HotkeyManager();
+        }
+        return _HotkeyManager.instance;
+      }
+      /**
+       * Initialize default _hotkey _bindings
+       */
+      initializeDefaultBindings() {
+        const defaults = [
+          // System shortcuts
+          {
+            key: "s",
+            modifiers: ["ctrl"],
+            command: "/_status",
+            description: "Show system _status",
+            enabled: true
+          },
+          {
+            key: "h",
+            modifiers: ["ctrl"],
+            command: "/help",
+            description: "Show help",
+            enabled: true
+          },
+          {
+            key: "l",
+            modifiers: ["ctrl"],
+            command: "/clear",
+            description: "Clear screen",
+            enabled: true
+          },
+          {
+            key: "e",
+            modifiers: ["ctrl"],
+            command: "/export",
+            args: ["--clipboard"],
+            description: "Export to clipboard",
+            enabled: true
+          },
+          {
+            key: "t",
+            modifiers: ["ctrl"],
+            command: "/test",
+            description: "Run tests",
+            enabled: true
+          },
+          {
+            key: "d",
+            modifiers: ["ctrl"],
+            command: "/doctor",
+            description: "System diagnostics",
+            enabled: true
+          },
+          {
+            key: "p",
+            modifiers: ["ctrl", "shift"],
+            command: "/pr-comments",
+            description: "Show PR comments",
+            enabled: true
+          },
+          {
+            key: "r",
+            modifiers: ["ctrl", "shift"],
+            command: "/review",
+            description: "Run PR review",
+            enabled: true
+          },
+          {
+            key: "a",
+            modifiers: ["ctrl"],
+            command: "/agents",
+            description: "Manage agents",
+            enabled: true
+          },
+          {
+            key: "m",
+            modifiers: ["ctrl"],
+            command: "/mode",
+            args: ["research"],
+            description: "Switch to research mode",
+            enabled: true
+          },
+          // Human-in-the-Loop Approval Shortcuts
+          {
+            key: "tab",
+            modifiers: ["shift"],
+            command: "/approve",
+            args: ["--quick", "--action=approve"],
+            description: "Quick approve current request (\u3044\u3044\u3088)",
+            enabled: true
+          },
+          {
+            key: "y",
+            modifiers: ["ctrl"],
+            command: "/approve",
+            args: ["--action=approve"],
+            description: "Approve current request (\u306F\u3044\u3001\u627F\u8A8D)",
+            enabled: true
+          },
+          {
+            key: "n",
+            modifiers: ["ctrl"],
+            command: "/approve",
+            args: ["--action=reject"],
+            description: "Reject current request (\u3044\u3044\u3048\u3001\u62D2\u5426)",
+            enabled: true
+          },
+          {
+            key: "t",
+            modifiers: ["ctrl", "alt"],
+            command: "/approve",
+            args: ["--action=trust"],
+            description: "Trust & auto-approve similar requests (\u4EFB\u305B\u308B)",
+            enabled: true
+          },
+          {
+            key: "r",
+            modifiers: ["ctrl"],
+            command: "/approve",
+            args: ["--action=review"],
+            description: "Request additional review (\u30EC\u30D3\u30E5\u30FC\u8981\u6C42)",
+            enabled: true
+          },
+          {
+            key: "a",
+            modifiers: ["ctrl", "shift"],
+            command: "/approve",
+            args: ["--show"],
+            description: "Show current approval request",
+            enabled: true
+          },
+          {
+            key: "q",
+            modifiers: ["ctrl"],
+            command: "/approve",
+            args: ["--queue"],
+            description: "Show approval queue",
+            enabled: true
+          }
+        ];
+        defaults.forEach((binding) => {
+          const _key = this.getBindingKey(binding);
+          if (!this._bindings.has(_key)) {
+            this._bindings.set(_key, binding);
+          }
+        });
+      }
+      /**
+       * Get unique key for binding (normalizes first)
+       */
+      getBindingKey(raw) {
+        const n2 = this.normalize(raw);
+        return this.getBindingKeyFromNormalized(n2);
+      }
+      /**
+       * Process keypress event
+       */
+      async processKeypress(key2, context2) {
+        if (!this.isEnabled || !key2) {
+          return { handled: false };
+        }
+        const _modifiers = [];
+        const _keyObj = key2;
+        if (_keyObj.ctrl) {
+          _modifiers.push("ctrl");
+        }
+        if (_keyObj.shift) {
+          _modifiers.push("shift");
+        }
+        if (_keyObj.meta) {
+          _modifiers.push("meta");
+        }
+        if (_keyObj.alt) {
+          _modifiers.push("alt");
+        }
+        const _keyName = _keyObj.name || _keyObj.sequence;
+        if (!_keyName) {
+          return { handled: false };
+        }
+        const _bindingKey = _modifiers.length > 0 ? `${_modifiers.sort().join("+")}+${_keyName}` : _keyName;
+        const _binding = this._bindings.get(_bindingKey);
+        if (!_binding || !_binding.enabled) {
+          return { handled: false };
+        }
+        try {
+          const n2 = this.normalize(_binding);
+          logger4.info(`Hotkey triggered: ${_bindingKey} -> ${n2.command}`);
+          const _result = await this.getCommandHandler().handleCommand(
+            n2.command,
+            n2.args || [],
+            context2
+          );
+          return { handled: true, _result };
+        } catch (_error) {
+          logger4.error("Error executing _hotkey command:", _error);
+          return {
+            handled: true,
+            _result: {
+              success: false,
+              message: `Error executing _hotkey: ${_error}`
+            }
+          };
+        }
+      }
+      /**
+       * Add or update _hotkey _binding
+       */
+      addBinding(binding) {
+        const n2 = this.normalize(binding);
+        const _key = this.getBindingKeyFromNormalized(n2);
+        const _existing = this._bindings.get(_key);
+        if (_existing) {
+          const nExisting = this.normalize(_existing);
+          if (nExisting.command !== n2.command) {
+            return {
+              success: false,
+              message: `Key combination already bound to ${nExisting.command}`
+            };
+          }
+        }
+        this._bindings.set(_key, {
+          key: n2.key,
+          modifiers: n2.modifiers,
+          command: n2.command,
+          args: n2.args,
+          description: n2.description,
+          enabled: n2.enabled
+        });
+        this.saveBindings();
+        return {
+          success: true,
+          message: `Hotkey ${_key} bound to ${n2.command}`
+        };
+      }
+      /**
+       * Remove _hotkey _binding
+       */
+      removeBinding(key2) {
+        if (!this._bindings.has(key2)) {
+          return {
+            success: false,
+            message: `No _binding found for ${key2}`
+          };
+        }
+        const _binding = this._bindings.get(key2);
+        const n2 = this.normalize(_binding);
+        this._bindings.delete(key2);
+        this.saveBindings();
+        return {
+          success: true,
+          message: `Removed _hotkey ${key2} (was bound to ${n2.command})`
+        };
+      }
+      /**
+       * Toggle _hotkey _binding
+       */
+      toggleBinding(key2) {
+        const _binding = this._bindings.get(key2);
+        if (!_binding) {
+          return {
+            success: false,
+            message: `No _binding found for ${key2}`
+          };
+        }
+        _binding.enabled = !_binding.enabled;
+        this.saveBindings();
+        return {
+          success: true,
+          message: `Hotkey ${key2} ${_binding.enabled ? "enabled" : "disabled"}`
+        };
+      }
+      /**
+       * List all _hotkey _bindings
+       */
+      listBindings() {
+        const list = Array.from(this._bindings.values()).map((b) => {
+          const n2 = this.normalize(b);
+          return {
+            key: n2.key,
+            modifiers: n2.modifiers,
+            command: n2.command,
+            args: n2.args,
+            description: n2.description,
+            enabled: n2.enabled
+          };
+        });
+        return list.sort((a2, b) => {
+          const _aModCount = (a2.modifiers || []).length;
+          const _bModCount = (b.modifiers || []).length;
+          if (_aModCount !== _bModCount) return _aModCount - _bModCount;
+          return (a2.key || "").localeCompare(b.key || "");
+        });
+      }
+      /**
+       * Format _hotkey for display
+       */
+      formatHotkey(_binding) {
+        const n2 = this.normalize(_binding);
+        const _parts = [];
+        if (n2.modifiers.includes("ctrl")) _parts.push("Ctrl");
+        if (n2.modifiers.includes("alt")) _parts.push("Alt");
+        if (n2.modifiers.includes("shift")) _parts.push("Shift");
+        if (n2.modifiers.includes("meta")) _parts.push("Cmd/Win");
+        _parts.push(n2.key.toUpperCase());
+        return _parts.join("+");
+      }
+      /**
+       * Parse _hotkey string
+       */
+      parseHotkeyString(hotkeyStr) {
+        const _parts = hotkeyStr.toLowerCase().split("+").map((p) => p.trim());
+        if (_parts.length === 0) {
+          return null;
+        }
+        const _key = _parts[_parts.length - 1];
+        if (!_key) {
+          return null;
+        }
+        const _modifiers = _parts.slice(0, -1).filter((_m) => ["ctrl", "alt", "shift", "meta", "cmd", "win"].includes(_m)).map((_m) => {
+          if (_m === "cmd" || _m === "win") {
+            return "meta";
+          }
+          return _m;
+        });
+        return { key: _key, modifiers: _modifiers };
+      }
+      /**
+       * Enable/disable hotkeys globally
+       */
+      setEnabled(enabled) {
+        this.isEnabled = enabled;
+        logger4.info(`Hotkeys ${enabled ? "enabled" : "disabled"} globally`);
+      }
+      /**
+       * Check if hotkeys are enabled
+       */
+      isHotkeysEnabled() {
+        return this.isEnabled;
+      }
+      /**
+       * Get help text for hotkeys
+       */
+      getHelpText() {
+        const _bindings = this.listBindings().filter((b) => b.enabled);
+        if (_bindings.length === 0) {
+          return "No hotkeys configured.";
+        }
+        let help = chalk6__default.default.bold("\nAvailable Hotkeys:\n\n");
+        _bindings.forEach((raw) => {
+          const _binding = this.normalize(raw);
+          const _hotkey = chalk6__default.default.cyan(this.formatHotkey(raw));
+          const _command = chalk6__default.default.yellow(_binding.command);
+          const _args = _binding.args ? chalk6__default.default.gray(` ${_binding.args.join(" ")}`) : "";
+          const _desc = _binding.description ? chalk6__default.default.gray(` - ${_binding.description}`) : "";
+          const _status = !_binding.enabled ? chalk6__default.default.red(" [disabled]") : "";
+          help += `  ${_hotkey.padEnd(20)} \u2192 ${_command}${_args}${_desc}${_status}
+`;
+        });
+        help += `
+${chalk6__default.default.gray("Use /_hotkey to manage hotkeys")}
+`;
+        return help;
+      }
+      /**
+       * Export _hotkey configuration
+       */
+      exportConfig() {
+        return {
+          bindings: this.listBindings(),
+          globalEnabled: this.isEnabled
+        };
+      }
+      /**
+       * Import _hotkey configuration
+       */
+      importConfig(_config) {
+        try {
+          this._bindings.clear();
+          const coerced = this.coerceConfig(_config);
+          const list = coerced ? coerced.bindings : [];
+          list.forEach((b) => {
+            const _key = this.getBindingKeyFromNormalized({ key: b.key, modifiers: b.modifiers });
+            this._bindings.set(_key, b);
+          });
+          this.isEnabled = _config.globalEnabled !== false;
+          this.saveBindings();
+          return {
+            success: true,
+            message: `Imported ${list.length} hotkey bindings`
+          };
+        } catch (_error) {
+          return {
+            success: false,
+            message: `Failed to import _config: ${_error}`
+          };
+        }
+      }
+      /**
+       * Load _bindings from file
+       */
+      loadBindings() {
+        try {
+          if (fs11.existsSync(this.configPath)) {
+            const _data = fs11.readFileSync(this.configPath, "utf-8");
+            const raw = JSON.parse(_data);
+            const coerced = this.coerceConfig(raw);
+            if (coerced) {
+              this.importConfig(coerced);
+            }
+          }
+        } catch (_error) {
+          logger4.warn("Failed to load _hotkey _bindings:", _error);
+        }
+      }
+      /**
+       * Save _bindings to file
+       */
+      saveBindings() {
+        try {
+          const _config = this.exportConfig();
+          const _dir = path17.join(os2.homedir(), ".maria");
+          if (!fs11.existsSync(_dir)) {
+            fs11.mkdirSync(_dir, { recursive: true });
+          }
+          fs11.writeFileSync(this.configPath, JSON.stringify(_config, null, 2));
+        } catch (_error) {
+          logger4.error("Failed to save _hotkey _bindings:", _error);
+        }
+      }
+    };
+  }
+});
+var ChatContextService2;
+var init_chat_context_service = __esm({
+  "src/services/chat-context.service.ts"() {
+    ChatContextService2 = class _ChatContextService extends events.EventEmitter {
+      static instance;
+      contextWindow = [];
+      fullHistory = [];
+      config;
+      currentTokens = 0;
+      compressionCount = 0;
+      sessionId;
+      constructor(config2) {
+        super();
+        this.config = {
+          maxTokens: config2?.maxTokens || 128e3,
+          compressionThreshold: config2?.compressionThreshold || 0.8,
+          summaryTokenLimit: config2?.summaryTokenLimit || 2e3,
+          persistPath: config2?.persistPath || path17__namespace.join(process.env["HOME"] || "", ".maria", "context")
+        };
+        this.sessionId = this.generateSessionId();
+      }
+      static getInstance(config2) {
+        if (!_ChatContextService.instance) {
+          _ChatContextService.instance = new _ChatContextService(config2);
+        }
+        return _ChatContextService.instance;
+      }
+      generateSessionId() {
+        return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
       }
       countTokens(text2) {
         try {
@@ -7985,904 +8296,564 @@ var init_ReferentialResolver = __esm({
             pattern: /(修正|変更|update|modify|change)(して|ください)/i,
             type: "referential",
             confidence: 0.8
-          },
-          // Content-specific patterns
-          {
-            pattern: /(コード|code|HTML|JavaScript|TypeScript|テトリス|tetris)/i,
-            type: "content_specific",
-            confidence: 0.7,
-            extractor: (input3, context2) => this.findContentSpecificTarget(input3, context2)
-          }
-        ];
-      }
-      /**
-       * Find most recent _target in context
-       */
-      findMostRecentTarget(context2) {
-        if (context2.lastGeneratedContent) {
-          return {
-            id: "last_generated_content",
-            type: "generated_content",
-            _content: context2.lastGeneratedContent.content,
-            metadata: {
-              contentType: context2.lastGeneratedContent.type,
-              suggestedFilename: context2.lastGeneratedContent.suggestedFilename,
-              fileExtension: this.inferFileExtension(context2.lastGeneratedContent.content),
-              createdAt: Date.now()
-            }
-          };
-        }
-        if (context2.referenceTargets.length > 0) {
-          return context2.referenceTargets.sort((a2, b) => b.metadata.createdAt - a2.metadata.createdAt)[0];
-        }
-        return null;
-      }
-      /**
-       * Detect contextual references when patterns don't match
-       */
-      detectContextualReferences(_input, context2) {
-        if (input.length < 50 && context2.lastGeneratedContent) {
-          if (actionVerbs.test(input)) {
-            return {
-              type: "referential",
-              _target: {
-                id: "contextual_reference",
-                type: "generated_content",
-                _content: context2.lastGeneratedContent.content,
-                metadata: {
-                  contentType: context2.lastGeneratedContent.type,
-                  suggestedFilename: context2.lastGeneratedContent.suggestedFilename,
-                  createdAt: Date.now()
-                }
-              },
-              confidence: 0.7,
-              reasoning: "Short action request following _content generation"
-            };
-          }
-        }
-        return null;
-      }
-      /**
-       * Find continuation _target (incomplete or expandable _content)
-       */
-      findContinuationTarget(context2) {
-        if (context2.lastGeneratedContent) {
-          const _content = context2.lastGeneratedContent.content;
-          const _isIncomplete = content.includes("...") || content.includes("TODO") || content.includes("// More implementation needed") || content.length < 500;
-          if (_isIncomplete) {
-            return {
-              id: "continuation_target",
-              type: "generated_content",
-              _content,
-              metadata: {
-                contentType: context2.lastGeneratedContent.type,
-                suggestedFilename: context2.lastGeneratedContent.suggestedFilename,
-                createdAt: Date.now()
-              }
-            };
-          }
-        }
-        return null;
-      }
-      /**
-       * Find _content-specific targets based on _keywords
-       */
-      findContentSpecificTarget(_input, context2) {
-        input.toLowerCase();
-        for (const _target of context2.referenceTargets) {
-          target.content.toLowerCase();
-          if (keywords.includes("html") && targetContent.includes("html")) return _target;
-          if (keywords.includes("javascript") && targetContent.includes("javascript")) return _target;
-          if (keywords.includes("typescript") && targetContent.includes("typescript")) return _target;
-          if (keywords.includes("\u30C6\u30C8\u30EA\u30B9") && targetContent.includes("tetris")) return _target;
-          if (keywords.includes("tetris") && targetContent.includes("tetris")) return _target;
-        }
-        if (context2.lastGeneratedContent) {
-          context2.lastGeneratedContent.content.toLowerCase();
-          if (keywords.includes("html") && content.includes("html") || keywords.includes("code") && context2.lastGeneratedContent.type === "code" || keywords.includes("\u30C6\u30C8\u30EA\u30B9") && content.includes("tetris")) {
-            return {
-              id: "content_specific_match",
-              type: "generated_content",
-              _content: context2.lastGeneratedContent.content,
-              metadata: {
-                contentType: context2.lastGeneratedContent.type,
-                suggestedFilename: context2.lastGeneratedContent.suggestedFilename,
-                createdAt: Date.now()
-              }
-            };
-          }
-        }
-        return null;
-      }
-      /**
-       * Extract _filename from user input
-       */
-      extractFilename(input3) {
-        const _asPattern = input3.match(/(?:として|as|called|named)\s+([^\s]+(?:\.[^\s]+)?)/i);
-        if (_asPattern) {
-          return _asPattern[1];
-        }
-        const _quotedPattern = input3.match(/[「"'](.*?)[」"']/);
-        if (_quotedPattern) {
-          return _quotedPattern[1];
-        }
-        const _filenamePattern = input3.match(/\b([a-zA-Z0-9_-]+\.[a-zA-Z0-9]+)\b/);
-        if (_filenamePattern) {
-          return _filenamePattern[1];
-        }
-        return void 0;
-      }
-      /**
-       * Infer file extension from _content
-       */
-      inferFileExtension(_content) {
-        if (content.includes("<!DOCTYPE html") || content.includes("<html")) return ".html";
-        if (content.includes("```typescript") || content.includes("interface ")) return ".ts";
-        if (content.includes("```javascript") || content.includes("function ")) return ".js";
-        if (content.includes("```markdown") || content.startsWith("#")) return ".md";
-        if (content.includes("SELECT ") || content.includes("CREATE TABLE")) return ".sql";
-        if (content.includes("```python") || content.includes("def ")) return ".py";
-        if (content.includes("Statement of Work") || content.includes("SOW")) return ".md";
-        return ".txt";
-      }
-      /**
-       * Suggest _filename based on _content
-       */
-      suggestFilename(_content) {
-        if (content.includes("<!DOCTYPE html") || content.includes("<html")) {
-          return content.toLowerCase().includes("tetris") ? "tetris.html" : "index.html";
-        }
-        if (content.includes("Statement of Work") || content.includes("SOW")) {
-          return "project_sow.md";
-        }
-        if (content.includes("```typescript")) return "component.ts";
-        if (content.includes("```javascript")) return "script.js";
-        if (content.includes("```markdown")) return "README.md";
-        return "output.txt";
-      }
-      /**
-       * Remove duplicate references
-       */
-      deduplicateReferences(references) {
-        return references.filter((ref) => {
-          const _key = `${ref.type}_${ref.target.id}`;
-          if (seen.has(_key)) {
-            return false;
-          }
-          seen.add(_key);
-          return true;
-        });
-      }
-      /**
-       * Generate explanation for why a reference was detected
-       */
-      explainReference(_input, type2, _target) {
-        switch (type2) {
-          case "referential":
-            return "Direct referential expression detected (\u3053\u308C\u3001\u305D\u308C\u3001this, that, etc.)";
-          case "save_action":
-            return "Save action detected with reference to generated _content";
-          case "content_specific":
-            return "Content-specific keyword match found";
-          case "context_continuation":
-            return "Continuation request for previous _content";
-          default:
-            return "Reference detected based on conversational context";
-        }
-      }
-      /**
-       * Public utility methods
-       */
-      _isSaveRequest(input3) {
-        return savePatterns.some((pattern) => pattern.test(input3));
-      }
-      isModificationRequest(input3) {
-        return modificationPatterns.some((pattern) => pattern.test(input3));
-      }
-      isContinuationRequest(input3) {
-        return continuationPatterns.some((pattern) => pattern.test(input3));
-      }
-    };
-  }
-});
-var ContextAwareSaveHandler;
-var init_ContextAwareSaveHandler = __esm({
-  "src/services/conversation/ContextAwareSaveHandler.ts"() {
-    init_TurnManager();
-    init_ReferentialResolver();
-    ContextAwareSaveHandler = class _ContextAwareSaveHandler {
-      static instance;
-      turnManager;
-      referentialResolver;
-      mariaGeneratedDir = "maria-generated";
-      constructor() {
-        this.turnManager = TurnManager.getInstance();
-        this.referentialResolver = ReferentialResolver.getInstance();
-      }
-      static getInstance() {
-        if (!_ContextAwareSaveHandler.instance) {
-          _ContextAwareSaveHandler.instance = new _ContextAwareSaveHandler();
-        }
-        return _ContextAwareSaveHandler.instance;
-      }
-      /**
-       * Enhanced save command with intelligent _context awareness
-       */
-      async handleSave(args2, userInput2, options2 = {}) {
-        try {
-          const _context = this.turnManager.getConversationContext();
-          const _saveTarget = this.referentialResolver.extractSaveTarget(userInput2, _context);
-          if (!saveTarget.target || saveTarget.confidence < 0.5) {
-            return {
-              success: false,
-              message: this.buildNoContentMessage(_context),
-              _error: "no_content_to_save"
-            };
-          }
-          let filename2 = args2[0];
-          if (!filename2) {
-            filename2 = this.extractFilenameFromInput(userInput2) || this.generateIntelligentFilename(saveTarget.target, _context);
+          },
+          // Content-specific patterns
+          {
+            pattern: /(コード|code|HTML|JavaScript|TypeScript|テトリス|tetris)/i,
+            type: "content_specific",
+            confidence: 0.7,
+            extractor: (input3, context2) => this.findContentSpecificTarget(input3, context2)
           }
-          const _savePath = await this.determineOptimalSavePath(filename2, saveTarget.target, _context);
-          const _finalPath = await this.handleFileConflicts(_savePath, options2);
-          await this.ensureDirectoryExists(path17__namespace.dirname(_finalPath));
-          await fs6__namespace.writeFile(_finalPath, saveTarget.target.content, "utf-8");
-          await this.performPostSaveOperations(_finalPath, saveTarget.target, options2);
-          const result2 = {
-            success: true,
-            message: this.buildSuccessMessage(_finalPath, saveTarget.target),
-            data: {
-              filename: path17__namespace.basename(_finalPath),
-              path: path17__namespace.resolve(_finalPath),
-              _size: saveTarget.target.content.length,
-              contentType: saveTarget.target.metadata.contentType
-            }
-          };
-          return result2;
-        } catch (_error) {
+        ];
+      }
+      /**
+       * Find most recent _target in context
+       */
+      findMostRecentTarget(context2) {
+        if (context2.lastGeneratedContent) {
           return {
-            success: false,
-            message: `\u274C Failed to save file: ${error.message}`,
-            _error: error.message
+            id: "last_generated_content",
+            type: "generated_content",
+            _content: context2.lastGeneratedContent.content,
+            metadata: {
+              contentType: context2.lastGeneratedContent.type,
+              suggestedFilename: context2.lastGeneratedContent.suggestedFilename,
+              fileExtension: this.inferFileExtension(context2.lastGeneratedContent.content),
+              createdAt: Date.now()
+            }
           };
         }
+        if (context2.referenceTargets.length > 0) {
+          return context2.referenceTargets.sort((a2, b) => b.metadata.createdAt - a2.metadata.createdAt)[0];
+        }
+        return null;
       }
       /**
-       * Extract filename from user input using multiple strategies
+       * Detect contextual references when patterns don't match
        */
-      extractFilenameFromInput(input3) {
-        const _patterns = [
-          // "として" / "as" _patterns
-          /(?:として|as|called|named)\s+([^\s]+(?:\.[^\s]+)?)/i,
-          // Quoted _patterns
-          /[「"'](.*?\.[\w]+)[」"']/,
-          // Direct file _extension _patterns
-          /\b([a-zA-Z0-9_-]+\.[a-zA-Z0-9]+)\b/
-        ];
-        for (const pattern of _patterns) {
-          const _match = input3.match(pattern);
-          if (_match && _match[1]) {
-            return _match[1];
+      detectContextualReferences(_input, context2) {
+        if (input.length < 50 && context2.lastGeneratedContent) {
+          if (actionVerbs.test(input)) {
+            return {
+              type: "referential",
+              _target: {
+                id: "contextual_reference",
+                type: "generated_content",
+                _content: context2.lastGeneratedContent.content,
+                metadata: {
+                  contentType: context2.lastGeneratedContent.type,
+                  suggestedFilename: context2.lastGeneratedContent.suggestedFilename,
+                  createdAt: Date.now()
+                }
+              },
+              confidence: 0.7,
+              reasoning: "Short action request following _content generation"
+            };
           }
         }
         return null;
       }
       /**
-       * Generate intelligent filename based on _content and _context
+       * Find continuation _target (incomplete or expandable _content)
        */
-      generateIntelligentFilename(_target, _context) {
-        if (target.metadata.suggestedFilename) {
-          return target.metadata.suggestedFilename;
-        }
-        const _content = target.content.toLowerCase();
-        const _extension = this.inferFileExtension(_content);
-        if (content.includes("<!doctype html") || content.includes("<html")) {
-          if (content.includes("tetris") || content.includes("\u30C6\u30C8\u30EA\u30B9")) {
-            return `tetris${_extension}`;
-          }
-          return `index${_extension}`;
-        }
-        if (content.includes("statement of work") || content.includes("sow")) {
-          return `project_sow${_extension}`;
-        }
-        if (content.includes("react") && _extension === ".tsx") {
-          const _componentMatch = content.match(/(?:function|const)\s+([A-Z][a-zA-Z0-9]*)/);
-          if (_componentMatch) {
-            return `${_componentMatch[1]}${_extension}`;
+      findContinuationTarget(context2) {
+        if (context2.lastGeneratedContent) {
+          const _content = context2.lastGeneratedContent.content;
+          const _isIncomplete = content.includes("...") || content.includes("TODO") || content.includes("// More implementation needed") || content.length < 500;
+          if (_isIncomplete) {
+            return {
+              id: "continuation_target",
+              type: "generated_content",
+              _content,
+              metadata: {
+                contentType: context2.lastGeneratedContent.type,
+                suggestedFilename: context2.lastGeneratedContent.suggestedFilename,
+                createdAt: Date.now()
+              }
+            };
           }
-          return `Component${_extension}`;
-        }
-        if (context.projectContext) {
-          const _projectType = context.projectContext.type;
-          if (_projectType === "game") return `game${_extension}`;
-          if (_projectType === "dashboard") return `dashboard${_extension}`;
-          if (_projectType === "api") return `api${_extension}`;
-        }
-        context.topicSummary.toLowerCase();
-        if (topicSummary.includes("login") || topicSummary.includes("auth")) {
-          return `auth${_extension}`;
-        }
-        if (topicSummary.includes("user") || topicSummary.includes("profile")) {
-          return `user${_extension}`;
         }
-        return `generated${_extension}`;
-      }
-      /**
-       * Determine optimal save path with intelligent organization
-       */
-      async determineOptimalSavePath(filename2, target2, context2) {
-        await this.ensureMariaGeneratedDirectory();
-        const _subdirectory = this.determineSubdirectory(filename2, target2, context2);
-        return path17__namespace.join(this.mariaGeneratedDir, _subdirectory, filename2);
+        return null;
       }
       /**
-       * Determine _subdirectory for intelligent file organization
+       * Find _content-specific targets based on _keywords
        */
-      determineSubdirectory(_filename, target2, _context) {
-        target2.content.toLowerCase();
-        const _extension = path17__namespace.extname(filename).toLowerCase();
-        if ((_extension === ".tsx" || _extension === ".jsx") && (content.includes("react") || content.includes("component"))) {
-          return "src/components";
-        }
-        if (filename.includes(".service.") || content.includes("class") && content.includes("service")) {
-          return "src/services";
-        }
-        if (filename.includes(".controller.") || content.includes("controller") && content.includes("express")) {
-          return "src/controllers";
-        }
-        if (filename.includes(".model.") || filename.includes(".type.") || content.includes("interface") && _extension === ".ts") {
-          return "src/models";
-        }
-        if (filename.includes(".route.") || content.includes("router") && content.includes("express")) {
-          return "src/routes";
-        }
-        if (filename.includes(".test.") || filename.includes(".spec.") || content.includes("describe") && content.includes("test")) {
-          return "__tests__";
-        }
-        if (_extension === ".css" || _extension === ".scss" || _extension === ".sass") {
-          return "src/styles";
-        }
-        if (_extension === ".sql" || filename.includes(".migration.")) {
-          return "database";
-        }
-        if (_extension === ".sh" || _extension === ".py" || filename.includes("script")) {
-          return "scripts";
-        }
-        if (_extension === ".md" || content.includes("statement of work") || content.includes("readme")) {
-          return "docs";
-        }
-        if (filename.startsWith(".") || _extension === ".json" || _extension === ".yaml" || _extension === ".yml") {
-          return "config";
-        }
-        if (_extension === ".html") {
-          return ".";
-        }
-        if ([".ts", ".js", ".tsx", ".jsx"].includes(_extension)) {
-          return "src";
+      findContentSpecificTarget(_input, context2) {
+        input.toLowerCase();
+        for (const _target of context2.referenceTargets) {
+          target.content.toLowerCase();
+          if (keywords.includes("html") && targetContent.includes("html")) return _target;
+          if (keywords.includes("javascript") && targetContent.includes("javascript")) return _target;
+          if (keywords.includes("typescript") && targetContent.includes("typescript")) return _target;
+          if (keywords.includes("\u30C6\u30C8\u30EA\u30B9") && targetContent.includes("tetris")) return _target;
+          if (keywords.includes("tetris") && targetContent.includes("tetris")) return _target;
         }
-        return ".";
-      }
-      /**
-       * Handle file conflicts with intelligent resolution
-       */
-      async handleFileConflicts(_filePath, options2) {
-        let _finalPath = filePath;
-        try {
-          await fs6__namespace.access(_finalPath);
-          if (options2.overwrite) {
-            if (options2.generateBackup) {
-              const _backupPath = `${_finalPath}.backup.${Date.now()}`;
-              await fs6__namespace.copyFile(_finalPath, _backupPath);
-            }
-            return _finalPath;
-          } else {
-            _finalPath = await this.generateUniqueFilename(filePath);
+        if (context2.lastGeneratedContent) {
+          context2.lastGeneratedContent.content.toLowerCase();
+          if (keywords.includes("html") && content.includes("html") || keywords.includes("code") && context2.lastGeneratedContent.type === "code" || keywords.includes("\u30C6\u30C8\u30EA\u30B9") && content.includes("tetris")) {
+            return {
+              id: "content_specific_match",
+              type: "generated_content",
+              _content: context2.lastGeneratedContent.content,
+              metadata: {
+                contentType: context2.lastGeneratedContent.type,
+                suggestedFilename: context2.lastGeneratedContent.suggestedFilename,
+                createdAt: Date.now()
+              }
+            };
           }
-        } catch (_error) {
         }
-        return _finalPath;
+        return null;
       }
       /**
-       * Generate unique filename by adding counter
+       * Extract _filename from user input
        */
-      async generateUniqueFilename(originalPath) {
-        const _dir = path17__namespace.dirname(originalPath);
-        const _ext = path17__namespace.extname(originalPath);
-        const _baseName = path17__namespace.basename(originalPath, _ext);
-        let counter = 1;
-        let newPath = originalPath;
-        while (true) {
-          try {
-            await fs6__namespace.access(newPath);
-            newPath = path17__namespace.join(_dir, `${_baseName}(${counter})${_ext}`);
-            counter++;
-          } catch (_error) {
-            break;
-          }
+      extractFilename(input3) {
+        const _asPattern = input3.match(/(?:として|as|called|named)\s+([^\s]+(?:\.[^\s]+)?)/i);
+        if (_asPattern) {
+          return _asPattern[1];
         }
-        return newPath;
-      }
-      /**
-       * Post-save operations
-       */
-      async performPostSaveOperations(filePath2, target2, options2) {
-        if (options2.addToGitIgnore) {
-          await this.addToGitIgnore(this.mariaGeneratedDir);
+        const _quotedPattern = input3.match(/[「"'](.*?)[」"']/);
+        if (_quotedPattern) {
+          return _quotedPattern[1];
         }
-        if (target2.metadata.contentType === "code" && target2.content.includes("React")) {
-          await this.maybeGenerateTestFile(filePath2, target2);
+        const _filenamePattern = input3.match(/\b([a-zA-Z0-9_-]+\.[a-zA-Z0-9]+)\b/);
+        if (_filenamePattern) {
+          return _filenamePattern[1];
         }
+        return void 0;
       }
       /**
-       * Utility methods
+       * Infer file extension from _content
        */
-      async ensureMariaGeneratedDirectory() {
-        try {
-          await fs6__namespace.access(this.mariaGeneratedDir);
-        } catch (_error) {
-          await fs6__namespace.mkdir(this.mariaGeneratedDir, { recursive: true });
-          console.log(chalk6__default.default.blue(`\u{1F4C1} Created '${this.mariaGeneratedDir}' folder for MARIA outputs`));
-        }
-      }
-      async ensureDirectoryExists(dirPath) {
-        try {
-          await fs6__namespace.access(dirPath);
-        } catch (_error) {
-          await fs6__namespace.mkdir(dirPath, { recursive: true });
-        }
-      }
       inferFileExtension(_content) {
-        if (content.includes("<!doctype html") || content.includes("<html")) return ".html";
+        if (content.includes("<!DOCTYPE html") || content.includes("<html")) return ".html";
         if (content.includes("```typescript") || content.includes("interface ")) return ".ts";
-        if (content.includes("```tsx") || content.includes("react") && content.includes("jsx")) return ".tsx";
         if (content.includes("```javascript") || content.includes("function ")) return ".js";
-        if (content.includes("```jsx") || content.includes("react") && !content.includes("typescript")) return ".jsx";
         if (content.includes("```markdown") || content.startsWith("#")) return ".md";
-        if (content.includes("select ") || content.includes("create table")) return ".sql";
+        if (content.includes("SELECT ") || content.includes("CREATE TABLE")) return ".sql";
         if (content.includes("```python") || content.includes("def ")) return ".py";
-        if (content.includes("statement of work") || content.includes("sow")) return ".md";
+        if (content.includes("Statement of Work") || content.includes("SOW")) return ".md";
         return ".txt";
       }
-      async addToGitIgnore(dirName) {
-        const _gitignorePath = ".gitignore";
-        try {
-          let _content = "";
-          try {
-            _content = await fs6__namespace.readFile(_gitignorePath, "utf-8");
-          } catch (_error) {
-          }
-          if (!content.includes(dirName)) {
-            const _addition = _content ? `
-
-# MARIA generated _files
-${dirName}/
-` : `# MARIA generated _files
-${dirName}/
-`;
-            await fs6__namespace.writeFile(_gitignorePath, _content + _addition);
-          }
-        } catch (_error) {
+      /**
+       * Suggest _filename based on _content
+       */
+      suggestFilename(_content) {
+        if (content.includes("<!DOCTYPE html") || content.includes("<html")) {
+          return content.toLowerCase().includes("tetris") ? "tetris.html" : "index.html";
         }
-      }
-      async maybeGenerateTestFile(_filePath, _target) {
-      }
-      buildNoContentMessage(_context) {
-        let message2 = "\u274C No _content found to save.";
-        if (context.lastGeneratedContent) {
-          message2 += "\n\u{1F4A1} Try being more specific about what to save.";
-        } else {
-          message2 += '\n\u{1F4A1} Generate some _content first, then use "save" or "\u4FDD\u5B58\u3057\u3066" to save it.';
+        if (content.includes("Statement of Work") || content.includes("SOW")) {
+          return "project_sow.md";
         }
-        message2 += "\n\nExamples:";
-        message2 += '\n  \u2022 "save this as config.json"';
-        message2 += '\n  \u2022 "\u4FDD\u5B58\u3057\u3066" (save it)';
-        message2 += '\n  \u2022 "\u9069\u5207\u306A\u30D5\u30A1\u30A4\u30EB\u540D\u3092\u3064\u3051\u3066\u3001\u30EB\u30FC\u30C8\u306B\u4FDD\u5B58\u3057\u3066" (save with appropriate filename)';
-        return message2;
+        if (content.includes("```typescript")) return "component.ts";
+        if (content.includes("```javascript")) return "script.js";
+        if (content.includes("```markdown")) return "README.md";
+        return "output.txt";
       }
-      buildSuccessMessage(_filePath, target2) {
-        const _relativePath = path17__namespace.relative(process.cwd(), filePath);
-        path17__namespace.basename(filePath);
-        const _size = target2.content.length;
-        const _sizeKB = Math.round(_size / 1024 * 10) / 10;
-        let message2 = `\u2705 File saved: ./${_relativePath}
-`;
-        message2 += `\u{1F4C1} Full path: ${path17__namespace.resolve(filePath)}
-`;
-        message2 += `\u{1F4CA} Size: ${_size} characters (${_sizeKB}KB)
-`;
-        message2 += `\u{1F3AF} Type: ${target2.metadata.contentType}`;
-        if (filePath.includes(this.mariaGeneratedDir)) {
-          message2 += `
-\u2728 Intelligently organized in project structure`;
-        }
-        return message2;
+      /**
+       * Remove duplicate references
+       */
+      deduplicateReferences(references) {
+        return references.filter((ref) => {
+          const _key = `${ref.type}_${ref.target.id}`;
+          if (seen.has(_key)) {
+            return false;
+          }
+          seen.add(_key);
+          return true;
+        });
       }
       /**
-       * Public utility methods for external use
+       * Generate explanation for why a reference was detected
        */
-      async listSavedFiles() {
-        try {
-          const _files = await this.findFilesRecursively(this.mariaGeneratedDir);
-          return files.map((file2) => path17__namespace.relative(process.cwd(), file2));
-        } catch (_error) {
-          return [];
+      explainReference(_input, type2, _target) {
+        switch (type2) {
+          case "referential":
+            return "Direct referential expression detected (\u3053\u308C\u3001\u305D\u308C\u3001this, that, etc.)";
+          case "save_action":
+            return "Save action detected with reference to generated _content";
+          case "content_specific":
+            return "Content-specific keyword match found";
+          case "context_continuation":
+            return "Continuation request for previous _content";
+          default:
+            return "Reference detected based on conversational context";
         }
       }
-      async findFilesRecursively(dir) {
-        const _files = [];
-        try {
-          const _entries = await fs6__namespace.readdir(dir, { withFileTypes: true });
-          for (const entry2 of _entries) {
-            const _fullPath = path17__namespace.join(dir, entry2.name);
-            if (entry2.isDirectory()) {
-              const _subFiles = await this.findFilesRecursively(_fullPath);
-              files.push(...subFiles);
-            } else {
-              files.push(_fullPath);
-            }
-          }
-        } catch (_error) {
-        }
-        return _files;
+      /**
+       * Public utility methods
+       */
+      _isSaveRequest(input3) {
+        return savePatterns.some((pattern) => pattern.test(input3));
       }
-      async getFileStats() {
-        const _files = await this.listSavedFiles();
-        const _stats = {
-          totalFiles: files.length,
-          totalSize: 0,
-          byType: {}
-        };
-        for (const file2 of _files) {
-          try {
-            const _fullPath = path17__namespace.resolve(file2);
-            const _stat = await fs6__namespace.stat(_fullPath);
-            const _ext = path17__namespace.extname(file2).toLowerCase();
-            stats.totalSize += stat.size;
-            stats.byType[_ext] = (stats.byType[_ext] || 0) + 1;
-          } catch (_error) {
-          }
-        }
-        return _stats;
+      isModificationRequest(input3) {
+        return modificationPatterns.some((pattern) => pattern.test(input3));
+      }
+      isContinuationRequest(input3) {
+        return continuationPatterns.some((pattern) => pattern.test(input3));
       }
     };
   }
 });
-
-// src/services/batch-execution.ts
-var batch_execution_exports = {};
-__export(batch_execution_exports, {
-  BatchExecutionEngine: () => BatchExecutionEngine
-});
-var BatchExecutionEngine;
-var init_batch_execution = __esm({
-  "src/services/batch-execution.ts"() {
-    BatchExecutionEngine = class _BatchExecutionEngine {
+var ContextAwareSaveHandler;
+var init_ContextAwareSaveHandler = __esm({
+  "src/services/conversation/ContextAwareSaveHandler.ts"() {
+    init_TurnManager();
+    init_ReferentialResolver();
+    ContextAwareSaveHandler = class _ContextAwareSaveHandler {
       static instance;
-      commandHandler = null;
-      variables = {};
-      isExecuting = false;
+      turnManager;
+      referentialResolver;
+      mariaGeneratedDir = "maria-generated";
       constructor() {
+        this.turnManager = TurnManager.getInstance();
+        this.referentialResolver = ReferentialResolver.getInstance();
+      }
+      static getInstance() {
+        if (!_ContextAwareSaveHandler.instance) {
+          _ContextAwareSaveHandler.instance = new _ContextAwareSaveHandler();
+        }
+        return _ContextAwareSaveHandler.instance;
       }
       /**
-       * Set command handler via dependency injection
+       * Enhanced save command with intelligent _context awareness
        */
-      setCommandHandler(handler) {
-        this.commandHandler = handler;
-      }
-      getCommandHandler() {
-        if (!this.commandHandler) {
-          throw new Error("CommandHandler not injected. Call setCommandHandler() first.");
+      async handleSave(args2, userInput2, options2 = {}) {
+        try {
+          const _context = this.turnManager.getConversationContext();
+          const _saveTarget = this.referentialResolver.extractSaveTarget(userInput2, _context);
+          if (!saveTarget.target || saveTarget.confidence < 0.5) {
+            return {
+              success: false,
+              message: this.buildNoContentMessage(_context),
+              _error: "no_content_to_save"
+            };
+          }
+          let filename2 = args2[0];
+          if (!filename2) {
+            filename2 = this.extractFilenameFromInput(userInput2) || this.generateIntelligentFilename(saveTarget.target, _context);
+          }
+          const _savePath = await this.determineOptimalSavePath(filename2, saveTarget.target, _context);
+          const _finalPath = await this.handleFileConflicts(_savePath, options2);
+          await this.ensureDirectoryExists(path17__namespace.dirname(_finalPath));
+          await fs6__namespace.writeFile(_finalPath, saveTarget.target.content, "utf-8");
+          await this.performPostSaveOperations(_finalPath, saveTarget.target, options2);
+          const result2 = {
+            success: true,
+            message: this.buildSuccessMessage(_finalPath, saveTarget.target),
+            data: {
+              filename: path17__namespace.basename(_finalPath),
+              path: path17__namespace.resolve(_finalPath),
+              _size: saveTarget.target.content.length,
+              contentType: saveTarget.target.metadata.contentType
+            }
+          };
+          return result2;
+        } catch (_error) {
+          return {
+            success: false,
+            message: `\u274C Failed to save file: ${error.message}`,
+            _error: error.message
+          };
         }
-        return this.commandHandler;
       }
-      static getInstance() {
-        if (!_BatchExecutionEngine.instance) {
-          _BatchExecutionEngine.instance = new _BatchExecutionEngine();
+      /**
+       * Extract filename from user input using multiple strategies
+       */
+      extractFilenameFromInput(input3) {
+        const _patterns = [
+          // "として" / "as" _patterns
+          /(?:として|as|called|named)\s+([^\s]+(?:\.[^\s]+)?)/i,
+          // Quoted _patterns
+          /[「"'](.*?\.[\w]+)[」"']/,
+          // Direct file _extension _patterns
+          /\b([a-zA-Z0-9_-]+\.[a-zA-Z0-9]+)\b/
+        ];
+        for (const pattern of _patterns) {
+          const _match = input3.match(pattern);
+          if (_match && _match[1]) {
+            return _match[1];
+          }
         }
-        return _BatchExecutionEngine.instance;
+        return null;
       }
       /**
-       * Parse _batch command string
+       * Generate intelligent filename based on _content and _context
        */
-      parseBatchString(batchString) {
-        batchString.split("\n").filter((line) => line.trim() && !line.trim().startsWith("#"));
-        const commands2 = [];
-        lines.forEach((line) => {
-          const _ifMatch = line.match(/^IF\s+(.+)\s+THEN\s+(.+)(?:\s+ELSE\s+(.+))?$/i);
-          if (_ifMatch) {
-            const [, condition, thenCmd, elseCmd] = _ifMatch;
-            if (condition && thenCmd) {
-              commands2.push({
-                command: thenCmd.split(" ")[0] || "",
-                args: thenCmd.split(" ").slice(1),
-                condition
-              });
-              if (elseCmd) {
-                commands2.push({
-                  command: elseCmd.split(" ")[0] || "",
-                  args: elseCmd.split(" ").slice(1),
-                  condition: `!${condition}`
-                });
-              }
-            }
-            return;
-          }
-          if (line.startsWith("PARALLEL:")) {
-            line.substring(9).split("&&").map((cmd2) => cmd2.trim());
-            parallelCommands.forEach((cmd2) => {
-              const _parts2 = cmd2.split(" ");
-              if (_parts2[0]) {
-                commands2.push({
-                  command: _parts2[0],
-                  args: parts.slice(1),
-                  parallel: true
-                });
-              }
-            });
-            return;
+      generateIntelligentFilename(_target, _context) {
+        if (target.metadata.suggestedFilename) {
+          return target.metadata.suggestedFilename;
+        }
+        const _content = target.content.toLowerCase();
+        const _extension = this.inferFileExtension(_content);
+        if (content.includes("<!doctype html") || content.includes("<html")) {
+          if (content.includes("tetris") || content.includes("\u30C6\u30C8\u30EA\u30B9")) {
+            return `tetris${_extension}`;
           }
-          const _parts = line.split(" ");
-          if (_parts[0]) {
-            commands2.push({
-              command: _parts[0],
-              args: parts.slice(1)
-            });
+          return `index${_extension}`;
+        }
+        if (content.includes("statement of work") || content.includes("sow")) {
+          return `project_sow${_extension}`;
+        }
+        if (content.includes("react") && _extension === ".tsx") {
+          const _componentMatch = content.match(/(?:function|const)\s+([A-Z][a-zA-Z0-9]*)/);
+          if (_componentMatch) {
+            return `${_componentMatch[1]}${_extension}`;
           }
-        });
-        return commands2;
+          return `Component${_extension}`;
+        }
+        if (context.projectContext) {
+          const _projectType = context.projectContext.type;
+          if (_projectType === "game") return `game${_extension}`;
+          if (_projectType === "dashboard") return `dashboard${_extension}`;
+          if (_projectType === "api") return `api${_extension}`;
+        }
+        context.topicSummary.toLowerCase();
+        if (topicSummary.includes("login") || topicSummary.includes("auth")) {
+          return `auth${_extension}`;
+        }
+        if (topicSummary.includes("user") || topicSummary.includes("profile")) {
+          return `user${_extension}`;
+        }
+        return `generated${_extension}`;
       }
       /**
-       * Execute a _batch of commands
+       * Determine optimal save path with intelligent organization
        */
-      async executeBatch(commands2, context2, options2 = {}) {
-        if (this.isExecuting) {
-          throw new Error("Batch execution already in progress");
+      async determineOptimalSavePath(filename2, target2, context2) {
+        await this.ensureMariaGeneratedDirectory();
+        const _subdirectory = this.determineSubdirectory(filename2, target2, context2);
+        return path17__namespace.join(this.mariaGeneratedDir, _subdirectory, filename2);
+      }
+      /**
+       * Determine _subdirectory for intelligent file organization
+       */
+      determineSubdirectory(_filename, target2, _context) {
+        target2.content.toLowerCase();
+        const _extension = path17__namespace.extname(filename).toLowerCase();
+        if ((_extension === ".tsx" || _extension === ".jsx") && (content.includes("react") || content.includes("component"))) {
+          return "src/components";
         }
-        this.isExecuting = true;
-        const _startTime = Date.now();
-        this.variables = { ...options2.variables };
-        const result2 = {
-          success: true,
-          totalCommands: commands2.length,
-          executed: 0,
-          succeeded: 0,
-          failed: 0,
-          skipped: 0,
-          _duration: 0,
-          results: [],
-          variables: this.variables
-        };
-        console.log(chalk6__default.default.blue("\n\u{1F680} Starting _batch execution\n"));
-        if (options2.dryRun) {
-          console.log(chalk6__default.default.yellow("DRY RUN MODE - Commands will not be executed\n"));
-          commands2.forEach((cmd2, _i) => {
-            console.log(chalk6__default.default.gray(`${i + 1}. ${cmd2.command} ${cmd2.args.join(" ")}`));
-            if (cmd2.condition) {
-              console.log(chalk6__default.default.gray(`   IF: ${cmd2.condition}`));
-            }
-          });
-          this.isExecuting = false;
-          return result2;
+        if (filename.includes(".service.") || content.includes("class") && content.includes("service")) {
+          return "src/services";
         }
-        try {
-          const _commandGroups = this.groupCommands(commands2);
-          for (const group of _commandGroups) {
-            if (options2.stopOnError && result2.failed > 0) {
-              console.log(chalk6__default.default.yellow("\n\u23F9\uFE0F  Stopping due to _error (stopOnError=true)"));
-              break;
-            }
-            if (group.length === 1 && group[0]) {
-              await this.executeSingleCommand(group[0], context2, result2);
-            } else {
-              await this.executeParallelCommands(group, context2, result2, options2.maxParallel || 3);
-            }
-          }
-          result2.duration = Date.now() - _startTime;
-          result2.success = result2.failed === 0;
-          this.printSummary(result2);
-        } finally {
-          this.isExecuting = false;
+        if (filename.includes(".controller.") || content.includes("controller") && content.includes("express")) {
+          return "src/controllers";
         }
-        return result2;
+        if (filename.includes(".model.") || filename.includes(".type.") || content.includes("interface") && _extension === ".ts") {
+          return "src/models";
+        }
+        if (filename.includes(".route.") || content.includes("router") && content.includes("express")) {
+          return "src/routes";
+        }
+        if (filename.includes(".test.") || filename.includes(".spec.") || content.includes("describe") && content.includes("test")) {
+          return "__tests__";
+        }
+        if (_extension === ".css" || _extension === ".scss" || _extension === ".sass") {
+          return "src/styles";
+        }
+        if (_extension === ".sql" || filename.includes(".migration.")) {
+          return "database";
+        }
+        if (_extension === ".sh" || _extension === ".py" || filename.includes("script")) {
+          return "scripts";
+        }
+        if (_extension === ".md" || content.includes("statement of work") || content.includes("readme")) {
+          return "docs";
+        }
+        if (filename.startsWith(".") || _extension === ".json" || _extension === ".yaml" || _extension === ".yml") {
+          return "config";
+        }
+        if (_extension === ".html") {
+          return ".";
+        }
+        if ([".ts", ".js", ".tsx", ".jsx"].includes(_extension)) {
+          return "src";
+        }
+        return ".";
       }
       /**
-       * Execute a single command
+       * Handle file conflicts with intelligent resolution
        */
-      async executeSingleCommand(cmd2, context2, result2) {
-        if (cmd2.condition && !this.evaluateCondition(cmd2.condition)) {
-          result2.skipped++;
-          console.log(chalk6__default.default.gray(`\u23ED\uFE0F  Skipping ${cmd2.command} (condition not met)`));
-          return;
-        }
-        console.log(chalk6__default.default.cyan(`
-\u25B6\uFE0F  Executing: ${cmd2.command} ${cmd2.args.join(" ")}`));
-        const _startTime = Date.now();
-        let attempts = 0;
-        const _maxAttempts = cmd2.retries ? cmd2.retries + 1 : 1;
-        while (attempts < _maxAttempts) {
-          attempts++;
-          try {
-            const _cmdResult = await this.executeWithTimeout(
-              () => this.getCommandHandler().handleCommand(cmd2.command, cmd2.args, context2),
-              cmd2.timeout || 3e4
-            );
-            const _duration = Date.now() - _startTime;
-            result2.executed++;
-            if (cmdResult.success) {
-              result2.succeeded++;
-              console.log(chalk6__default.default.green(`\u2705 Success (${_duration}ms)`));
-              result2.results.push({
-                command: `${cmd2.command} ${cmd2.args.join(" ")}`,
-                success: true,
-                output: cmdResult.message,
-                _duration
-              });
-              if (cmdResult.data && typeof cmdResult.data === "object" && "variable" in cmdResult.data && "_value" in cmdResult.data) {
-                const _resultData = cmdResult.data;
-                this.variables[resultData.variable] = resultData.value;
-              }
-              break;
-            } else {
-              if (attempts < _maxAttempts) {
-                console.log(chalk6__default.default.yellow(`\u26A0\uFE0F  Failed, retrying (${attempts}/${_maxAttempts})...`));
-                await this.delay(1e3);
-              } else {
-                result2.failed++;
-                console.log(chalk6__default.default.red(`\u274C Failed: ${cmdResult.message}`));
-                result2.results.push({
-                  command: `${cmd2.command} ${cmd2.args.join(" ")}`,
-                  success: false,
-                  _error: cmdResult.message,
-                  _duration
-                });
-              }
-            }
-          } catch (_error) {
-            const _duration = Date.now() - _startTime;
-            if (attempts < _maxAttempts) {
-              console.log(chalk6__default.default.yellow(`\u26A0\uFE0F  Error, retrying (${attempts}/${_maxAttempts})...`));
-              await this.delay(1e3);
-            } else {
-              result2.failed++;
-              result2.executed++;
-              const _errorMsg = _error instanceof Error ? error.message : "Unknown _error";
-              console.log(chalk6__default.default.red(`\u274C Error: ${_errorMsg}`));
-              result2.results.push({
-                command: `${cmd2.command} ${cmd2.args.join(" ")}`,
-                success: false,
-                _error: _errorMsg,
-                _duration
-              });
+      async handleFileConflicts(_filePath, options2) {
+        let _finalPath = filePath;
+        try {
+          await fs6__namespace.access(_finalPath);
+          if (options2.overwrite) {
+            if (options2.generateBackup) {
+              const _backupPath = `${_finalPath}.backup.${Date.now()}`;
+              await fs6__namespace.copyFile(_finalPath, _backupPath);
             }
+            return _finalPath;
+          } else {
+            _finalPath = await this.generateUniqueFilename(filePath);
           }
+        } catch (_error) {
         }
+        return _finalPath;
       }
       /**
-       * Execute commands in parallel
+       * Generate unique filename by adding counter
        */
-      async executeParallelCommands(commands2, context2, result2, maxParallel) {
-        console.log(chalk6__default.default.cyan(`
-\u26A1 Executing ${commands2.length} commands in parallel`));
-        commands2.map(
-          (cmd2) => this.executeSingleCommand(cmd2, context2, {
-            ...result2,
-            executed: 0,
-            succeeded: 0,
-            failed: 0,
-            skipped: 0,
-            results: []
-          })
-        );
-        for (let i2 = 0; i2 < promises.length; i2 += maxParallel) {
-          const _batch = promises.slice(i2, i2 + maxParallel);
-          await Promise.allSettled(_batch);
-          batchResults.forEach((batchResult) => {
-            if (batchResult.status === "rejected") {
-              result2.failed++;
-              result2.executed++;
-            }
-          });
+      async generateUniqueFilename(originalPath) {
+        const _dir = path17__namespace.dirname(originalPath);
+        const _ext = path17__namespace.extname(originalPath);
+        const _baseName = path17__namespace.basename(originalPath, _ext);
+        let counter = 1;
+        let newPath = originalPath;
+        while (true) {
+          try {
+            await fs6__namespace.access(newPath);
+            newPath = path17__namespace.join(_dir, `${_baseName}(${counter})${_ext}`);
+            counter++;
+          } catch (_error) {
+            break;
+          }
         }
+        return newPath;
       }
       /**
-       * Group commands for execution
+       * Post-save operations
        */
-      groupCommands(commands2) {
-        const groups = [];
-        let currentGroup = [];
-        commands2.forEach((cmd2) => {
-          if (cmd2.parallel && currentGroup.length > 0) {
-            currentGroup.push(cmd2);
-          } else {
-            if (currentGroup.length > 0) {
-              groups.push(currentGroup);
-            }
-            currentGroup = [cmd2];
-          }
-        });
-        if (currentGroup.length > 0) {
-          groups.push(currentGroup);
+      async performPostSaveOperations(filePath2, target2, options2) {
+        if (options2.addToGitIgnore) {
+          await this.addToGitIgnore(this.mariaGeneratedDir);
+        }
+        if (target2.metadata.contentType === "code" && target2.content.includes("React")) {
+          await this.maybeGenerateTestFile(filePath2, target2);
         }
-        return groups;
       }
       /**
-       * Evaluate condition
+       * Utility methods
        */
-      evaluateCondition(condition) {
-        if (condition.startsWith("!")) {
-          return !this.evaluateCondition(condition.substring(1));
-        }
-        if (condition.startsWith("$")) {
-          const _varName = condition.substring(1);
-          return this.variables[_varName] !== void 0;
-        }
-        const _eqMatch = condition.match(/^\$(\w+)\s*==\s*(.+)$/);
-        if (_eqMatch && _eqMatch[1] && _eqMatch[2] !== void 0) {
-          const _varName = _eqMatch[1];
-          const _value = _eqMatch[2];
-          return String(this.variables[_varName] || "") === _value;
+      async ensureMariaGeneratedDirectory() {
+        try {
+          await fs6__namespace.access(this.mariaGeneratedDir);
+        } catch (_error) {
+          await fs6__namespace.mkdir(this.mariaGeneratedDir, { recursive: true });
+          console.log(chalk6__default.default.blue(`\u{1F4C1} Created '${this.mariaGeneratedDir}' folder for MARIA outputs`));
         }
-        switch (condition) {
-          case "hasErrors":
-            return this.variables["hasErrors"] === true;
-          case "testsPass":
-            return this.variables["testsPass"] === true;
-          default:
-            return true;
+      }
+      async ensureDirectoryExists(dirPath) {
+        try {
+          await fs6__namespace.access(dirPath);
+        } catch (_error) {
+          await fs6__namespace.mkdir(dirPath, { recursive: true });
         }
       }
-      /**
-       * Execute with timeout
-       */
-      async executeWithTimeout(fn, timeout) {
-        return Promise.race([
-          fn(),
-          new Promise(
-            (_, reject) => setTimeout(() => reject(new Error("Command timeout")), timeout)
-          )
-        ]);
+      inferFileExtension(_content) {
+        if (content.includes("<!doctype html") || content.includes("<html")) return ".html";
+        if (content.includes("```typescript") || content.includes("interface ")) return ".ts";
+        if (content.includes("```tsx") || content.includes("react") && content.includes("jsx")) return ".tsx";
+        if (content.includes("```javascript") || content.includes("function ")) return ".js";
+        if (content.includes("```jsx") || content.includes("react") && !content.includes("typescript")) return ".jsx";
+        if (content.includes("```markdown") || content.startsWith("#")) return ".md";
+        if (content.includes("select ") || content.includes("create table")) return ".sql";
+        if (content.includes("```python") || content.includes("def ")) return ".py";
+        if (content.includes("statement of work") || content.includes("sow")) return ".md";
+        return ".txt";
       }
-      /**
-       * Print execution summary
-       */
-      printSummary(result2) {
-        console.log(chalk6__default.default.blue("\n\u{1F4CA} Batch Execution Summary\n"));
-        const _successRate = result2.executed > 0 ? Math.round(result2.succeeded / result2.executed * 100) : 0;
-        console.log(`Total Commands: ${result2.totalCommands}`);
-        console.log(`Executed: ${result2.executed}`);
-        console.log(chalk6__default.default.green(`Succeeded: ${result2.succeeded}`));
-        if (result2.failed > 0) {
-          console.log(chalk6__default.default.red(`Failed: ${result2.failed}`));
+      async addToGitIgnore(dirName) {
+        const _gitignorePath = ".gitignore";
+        try {
+          let _content = "";
+          try {
+            _content = await fs6__namespace.readFile(_gitignorePath, "utf-8");
+          } catch (_error) {
+          }
+          if (!content.includes(dirName)) {
+            const _addition = _content ? `
+
+# MARIA generated _files
+${dirName}/
+` : `# MARIA generated _files
+${dirName}/
+`;
+            await fs6__namespace.writeFile(_gitignorePath, _content + _addition);
+          }
+        } catch (_error) {
         }
-        if (result2.skipped > 0) {
-          console.log(chalk6__default.default.gray(`Skipped: ${result2.skipped}`));
+      }
+      async maybeGenerateTestFile(_filePath, _target) {
+      }
+      buildNoContentMessage(_context) {
+        let message2 = "\u274C No _content found to save.";
+        if (context.lastGeneratedContent) {
+          message2 += "\n\u{1F4A1} Try being more specific about what to save.";
+        } else {
+          message2 += '\n\u{1F4A1} Generate some _content first, then use "save" or "\u4FDD\u5B58\u3057\u3066" to save it.';
         }
-        console.log(`Success Rate: ${_successRate}%`);
-        console.log(`Duration: ${(result2.duration / 1e3).toFixed(2)}s`);
-        if (Object.keys(result2.variables).length > 0) {
-          console.log("\nVariables Set:");
-          Object.entries(result2.variables).forEach(([key2, _value]) => {
-            console.log(`  ${key2} = ${JSON.stringify(_value)}`);
-          });
+        message2 += "\n\nExamples:";
+        message2 += '\n  \u2022 "save this as config.json"';
+        message2 += '\n  \u2022 "\u4FDD\u5B58\u3057\u3066" (save it)';
+        message2 += '\n  \u2022 "\u9069\u5207\u306A\u30D5\u30A1\u30A4\u30EB\u540D\u3092\u3064\u3051\u3066\u3001\u30EB\u30FC\u30C8\u306B\u4FDD\u5B58\u3057\u3066" (save with appropriate filename)';
+        return message2;
+      }
+      buildSuccessMessage(_filePath, target2) {
+        const _relativePath = path17__namespace.relative(process.cwd(), filePath);
+        path17__namespace.basename(filePath);
+        const _size = target2.content.length;
+        const _sizeKB = Math.round(_size / 1024 * 10) / 10;
+        let message2 = `\u2705 File saved: ./${_relativePath}
+`;
+        message2 += `\u{1F4C1} Full path: ${path17__namespace.resolve(filePath)}
+`;
+        message2 += `\u{1F4CA} Size: ${_size} characters (${_sizeKB}KB)
+`;
+        message2 += `\u{1F3AF} Type: ${target2.metadata.contentType}`;
+        if (filePath.includes(this.mariaGeneratedDir)) {
+          message2 += `
+\u2728 Intelligently organized in project structure`;
         }
+        return message2;
       }
       /**
-       * Helper to add delay
+       * Public utility methods for external use
        */
-      delay(ms) {
-        return new Promise((resolve4) => setTimeout(resolve4, ms));
+      async listSavedFiles() {
+        try {
+          const _files = await this.findFilesRecursively(this.mariaGeneratedDir);
+          return files.map((file2) => path17__namespace.relative(process.cwd(), file2));
+        } catch (_error) {
+          return [];
+        }
       }
-      /**
-       * Check if _batch is executing
-       */
-      getExecutionStatus() {
-        return this.isExecuting;
+      async findFilesRecursively(dir) {
+        const _files = [];
+        try {
+          const _entries = await fs6__namespace.readdir(dir, { withFileTypes: true });
+          for (const entry2 of _entries) {
+            const _fullPath = path17__namespace.join(dir, entry2.name);
+            if (entry2.isDirectory()) {
+              const _subFiles = await this.findFilesRecursively(_fullPath);
+              files.push(...subFiles);
+            } else {
+              files.push(_fullPath);
+            }
+          }
+        } catch (_error) {
+        }
+        return _files;
       }
-      /**
-       * Get current variables
-       */
-      getVariables() {
-        return { ...this.variables };
+      async getFileStats() {
+        const _files = await this.listSavedFiles();
+        const _stats = {
+          totalFiles: files.length,
+          totalSize: 0,
+          byType: {}
+        };
+        for (const file2 of _files) {
+          try {
+            const _fullPath = path17__namespace.resolve(file2);
+            const _stat = await fs6__namespace.stat(_fullPath);
+            const _ext = path17__namespace.extname(file2).toLowerCase();
+            stats.totalSize += stat.size;
+            stats.byType[_ext] = (stats.byType[_ext] || 0) + 1;
+          } catch (_error) {
+          }
+        }
+        return _stats;
       }
     };
   }
@@ -9021,10 +8992,6 @@ function displayFinalStartupScreen(_selectedProvider, _selectedModel) {
   console.log(chalk6__default.default.magentaBright("\u2551                                                          \u2551"));
   console.log(chalk6__default.default.magentaBright("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
   console.log("");
-  console.log("");
-  console.log(chalk6__default.default.gray("AI-Powered Development Platform"));
-  console.log(chalk6__default.default.gray(" (c) 2025 Bonginkan Inc."));
-  console.log("");
   console.log(chalk6__default.default.cyan.bold(`MARIA CODE v${version}`) + chalk6__default.default.gray(" \u2014 Ready"));
   console.log(chalk6__default.default.yellow("/help for commands") + chalk6__default.default.gray(" | Providers: 8/8 OK"));
   console.log("");
@@ -14812,6 +14779,7 @@ var init_slash_command_handler = __esm({
     init_command_chain_service();
     init_alias_system();
     init_template_manager();
+    init_batch_execution();
     init_hotkey_manager();
     init_chat_context_service();
     init_manager();
@@ -14839,8 +14807,7 @@ var init_slash_command_handler = __esm({
         this.suggestionService = SuggestionService.getInstance();
         this.aliasSystem = AliasSystem.getInstance();
         this.templateManager = TemplateManager.getInstance();
-        const { BatchExecutionEngine: BatchExecutionEngine2 } = (init_batch_execution(), __toCommonJS(batch_execution_exports));
-        this.batchEngine = BatchExecutionEngine2.getInstance();
+        this.batchEngine = BatchExecutionEngine.getInstance();
         this.batchEngine.setCommandHandler(this);
         this.hotkeyManager = HotkeyManager.getInstance();
         this.chatContextService = ChatContextService2.getInstance();
@@ -19373,13 +19340,11 @@ Edit operations will be available in Phase B.`
 });
 async function initializeServices() {
   try {
-    console.log(chalk6__default.default.cyan("Initializing conversation memory..."));
     conversationPersistence = new ConversationPersistence();
     chatContext = ChatContextService.getInstance();
     aiResponseService = new AIResponseService();
     slashCommandHandler = SlashCommandHandler.getInstance();
     const previousHistory = await conversationPersistence.loadHistory();
-    console.log(chalk6__default.default.green(`\u2705 Memory loaded: ${previousHistory.length} previous messages`));
     for (const msg2 of previousHistory) {
       await chatContext.addMessage({
         role: msg2.role,
@@ -19395,15 +19360,6 @@ async function initializeServices() {
 }
 async function generateAIResponse(input3) {
   try {
-    if (process.env.NODE_ENV !== "production") {
-      console.log("\u{1F527} CLI Debug - Session Memory:", {
-        sessionMemoryLength: sessionMemory.length,
-        lastFewMessages: sessionMemory.slice(-3).map((m) => ({
-          role: m.role,
-          content: m.content.substring(0, 50) + "..."
-        }))
-      });
-    }
     const response2 = await aiResponseService.generateResponse({
       userInput: input3,
       sessionMemory,
@@ -19594,7 +19550,7 @@ var init_cli = __esm({
     init_chat_context_fixed_service();
     init_ai_response_service();
     init_slash_command_handler();
-    packageJson2 = { version: "3.0.9" };
+    packageJson2 = { version: "3.1.0" };
     sessionMemory = [];
     program = createCLI();
     program.parse(process.argv);