@elizaos/cli 1.6.2-alpha.14 → 1.6.2-alpha.16

package/dist/index.js

@@ -4749,7 +4749,7 @@ __export(exports_version, {
   BUILD_TIME: () => BUILD_TIME,
   BUILD_ENV: () => BUILD_ENV
 });
-var CLI_VERSION = "1.6.2-alpha.14", CLI_NAME = "@elizaos/cli", CLI_DESCRIPTION = "elizaOS CLI - Manage your AI agents and plugins", BUILD_TIME = "2025-10-12T22:21:35.709Z", BUILD_ENV = "production", version_default;
+var CLI_VERSION = "1.6.2-alpha.16", CLI_NAME = "@elizaos/cli", CLI_DESCRIPTION = "elizaOS CLI - Manage your AI agents and plugins", BUILD_TIME = "2025-10-15T17:36:44.719Z", BUILD_ENV = "production", version_default;
 var init_version = __esm(() => {
   version_default = {
     version: CLI_VERSION,
@@ -278447,14 +278447,14 @@ function resolveYamlBinary(data) {
   return bitlen % 8 === 0;
 }
 function constructYamlBinary(data) {
-  var idx, tailbits, input2 = data.replace(/[\r\n=]/g, ""), max = input2.length, map4 = BASE64_MAP, bits = 0, result = [];
+  var idx, tailbits, input3 = data.replace(/[\r\n=]/g, ""), max = input3.length, map4 = BASE64_MAP, bits = 0, result = [];
   for (idx = 0;idx < max; idx++) {
     if (idx % 4 === 0 && idx) {
       result.push(bits >> 16 & 255);
       result.push(bits >> 8 & 255);
       result.push(bits & 255);
     }
-    bits = bits << 6 | map4.indexOf(input2.charAt(idx));
+    bits = bits << 6 | map4.indexOf(input3.charAt(idx));
   }
   tailbits = max % 4 * 6;
   if (tailbits === 0) {
@@ -278628,8 +278628,8 @@ function charFromCodepoint(c) {
   }
   return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
 }
-function State$1(input2, options) {
-  this.input = input2;
+function State$1(input3, options) {
+  this.input = input3;
   this.filename = options["filename"] || null;
   this.schema = options["schema"] || _default3;
   this.onWarning = options["onWarning"] || null;
@@ -278638,7 +278638,7 @@ function State$1(input2, options) {
   this.listener = options["listener"] || null;
   this.implicitTypes = this.schema.compiledImplicit;
   this.typeMap = this.schema.compiledTypeMap;
-  this.length = input2.length;
+  this.length = input3.length;
   this.position = 0;
   this.line = 0;
   this.lineStart = 0;
@@ -279616,20 +279616,20 @@ function readDocument(state) {
     return;
   }
 }
-function loadDocuments(input2, options) {
-  input2 = String(input2);
+function loadDocuments(input3, options) {
+  input3 = String(input3);
   options = options || {};
-  if (input2.length !== 0) {
-    if (input2.charCodeAt(input2.length - 1) !== 10 && input2.charCodeAt(input2.length - 1) !== 13) {
-      input2 += `
+  if (input3.length !== 0) {
+    if (input3.charCodeAt(input3.length - 1) !== 10 && input3.charCodeAt(input3.length - 1) !== 13) {
+      input3 += `
 `;
     }
-    if (input2.charCodeAt(0) === 65279) {
-      input2 = input2.slice(1);
+    if (input3.charCodeAt(0) === 65279) {
+      input3 = input3.slice(1);
     }
   }
-  var state = new State$1(input2, options);
-  var nullpos = input2.indexOf("\x00");
+  var state = new State$1(input3, options);
+  var nullpos = input3.indexOf("\x00");
   if (nullpos !== -1) {
     state.position = nullpos;
     throwError(state, "null byte is not allowed in input");
@@ -279644,12 +279644,12 @@ function loadDocuments(input2, options) {
   }
   return state.documents;
 }
-function loadAll$1(input2, iterator2, options) {
+function loadAll$1(input3, iterator2, options) {
   if (iterator2 !== null && typeof iterator2 === "object" && typeof options === "undefined") {
     options = iterator2;
     iterator2 = null;
   }
-  var documents = loadDocuments(input2, options);
+  var documents = loadDocuments(input3, options);
   if (typeof iterator2 !== "function") {
     return documents;
   }
@@ -279657,8 +279657,8 @@ function loadAll$1(input2, iterator2, options) {
     iterator2(documents[index]);
   }
 }
-function load$1(input2, options) {
-  var documents = loadDocuments(input2, options);
+function load$1(input3, options) {
+  var documents = loadDocuments(input3, options);
   if (documents.length === 0) {
     return;
   } else if (documents.length === 1) {
@@ -280209,12 +280209,12 @@ function inspectNode(object2, objects, duplicatesIndexes) {
     }
   }
 }
-function dump$1(input2, options) {
+function dump$1(input3, options) {
   options = options || {};
   var state = new State(options);
   if (!state.noRefs)
-    getDuplicateReferences(input2, state);
-  var value = input2;
+    getDuplicateReferences(input3, state);
+  var value = input3;
   if (state.replacer) {
     value = state.replacer.call({ "": value }, "", value);
   }
@@ -280783,7 +280783,7 @@ import { AgentServer } from "@elizaos/server";
 import { ElizaClient } from "@elizaos/api-client";
 import { ChannelType, stringToUuid as stringToUuidCore } from "@elizaos/core";
 import fs50 from "fs";
-import path74 from "path";
+import path75 from "path";
 import { createServer } from "net";
 async function findAvailablePort(startPort, endPort, host) {
   const serverHost = host || process.env.SERVER_HOST || "0.0.0.0";
@@ -280838,8 +280838,8 @@ async function createScenarioServer(existingServer = null, desiredPort = 3000) {
         server2 = existingServer;
       } else {
         server2 = new AgentServer;
-        const pgliteRoot = process.env.PGLITE_DATA_DIR || path74.join(process.cwd(), ".eliza", ".elizadb");
-        const uniqueDataDir = path74.join(pgliteRoot, `scenario-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        const pgliteRoot = process.env.PGLITE_DATA_DIR || path75.join(process.cwd(), ".eliza", ".elizadb");
+        const uniqueDataDir = path75.join(pgliteRoot, `scenario-${Date.now()}-${Math.random().toString(36).slice(2)}`);
         try {
           fs50.mkdirSync(uniqueDataDir, { recursive: true });
         } catch {}
@@ -280929,9 +280929,9 @@ async function shutdownScenarioServer(server2, port) {
     }
   }
 }
-async function askAgentViaApi(server2, agentId, input2, timeoutMs = 60000, serverPort, existingChannelId) {
+async function askAgentViaApi(server2, agentId, input3, timeoutMs = 60000, serverPort, existingChannelId) {
   console.log(`\uD83D\uDD27 [askAgentViaApi] === FUNCTION START ===`);
-  console.log(`\uD83D\uDD27 [askAgentViaApi] Parameters: agentId=${agentId}, input="${input2}", serverPort=${serverPort}, existingChannelId=${existingChannelId}`);
+  console.log(`\uD83D\uDD27 [askAgentViaApi] Parameters: agentId=${agentId}, input="${input3}", serverPort=${serverPort}, existingChannelId=${existingChannelId}`);
   try {
     const port = serverPort ?? server2?.port ?? 3000;
     console.log(`\uD83D\uDD27 [askAgentViaApi] Port calculation: provided=${serverPort}, server.port=${server2?.port}, final=${port}`);
@@ -281031,7 +281031,7 @@ async function askAgentViaApi(server2, agentId, input2, timeoutMs = 60000, serve
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         author_id: testUserId,
-        content: input2,
+        content: input3,
         server_id: defaultServer.id,
         metadata: { scenario: true, user_display_name: "Scenario User" },
         source_type: "scenario_message"
@@ -281801,7 +281801,7 @@ class EnhancedFileExistsEvaluator {
     const expectedPath = params.path;
     const createdFiles = Object.keys(runResult.files);
     const success3 = createdFiles.includes(expectedPath) || createdFiles.includes(`./${expectedPath}`) || createdFiles.includes(expectedPath.replace(/^\.\//, ""));
-    const matchingPath = createdFiles.find((path75) => path75 === expectedPath || path75 === `./${expectedPath}` || path75 === expectedPath.replace(/^\.\//, ""));
+    const matchingPath = createdFiles.find((path76) => path76 === expectedPath || path76 === `./${expectedPath}` || path76 === expectedPath.replace(/^\.\//, ""));
     return {
       evaluator_type: "file_exists",
       success: success3,
@@ -282845,7 +282845,7 @@ __export(exports_LocalEnvironmentProvider, {
   LocalEnvironmentProvider: () => LocalEnvironmentProvider
 });
 import fs51 from "fs/promises";
-import path75 from "path";
+import path76 from "path";
 import os11 from "os";
 
 class LocalEnvironmentProvider {
@@ -282869,13 +282869,13 @@ class LocalEnvironmentProvider {
     console.log(`\uD83D\uDD27 [DEBUG]   - Server Port: ${serverPort}`);
   }
   async setup(scenario) {
-    const tempDirPrefix = path75.join(os11.tmpdir(), "eliza-scenario-run-");
+    const tempDirPrefix = path76.join(os11.tmpdir(), "eliza-scenario-run-");
     this.tempDir = await fs51.mkdtemp(tempDirPrefix);
     const virtualFs = scenario.setup?.virtual_fs;
     if (virtualFs) {
       for (const [filePath, content] of Object.entries(virtualFs)) {
-        const fullPath = path75.join(this.tempDir, filePath);
-        await fs51.mkdir(path75.dirname(fullPath), { recursive: true });
+        const fullPath = path76.join(this.tempDir, filePath);
+        await fs51.mkdir(path76.dirname(fullPath), { recursive: true });
         await fs51.writeFile(fullPath, content);
       }
     }
@@ -282889,8 +282889,8 @@ class LocalEnvironmentProvider {
       const readDirRecursive = async (dirPath, basePath = "") => {
         const entries = await fs51.readdir(dirPath, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path75.join(dirPath, entry.name);
-          const relativePath = path75.join(basePath, entry.name);
+          const fullPath = path76.join(dirPath, entry.name);
+          const relativePath = path76.join(basePath, entry.name);
           if (entry.isDirectory()) {
             await readDirRecursive(fullPath, relativePath);
           } else if (entry.isFile()) {
@@ -284333,11 +284333,11 @@ var require_lodash = __commonJS((exports, module) => {
           return isFunction3(object2[key]);
         });
       }
-      function baseGet(object2, path76) {
-        path76 = castPath(path76, object2);
-        var index = 0, length = path76.length;
+      function baseGet(object2, path77) {
+        path77 = castPath(path77, object2);
+        var index = 0, length = path77.length;
         while (object2 != null && index < length) {
-          object2 = object2[toKey(path76[index++])];
+          object2 = object2[toKey(path77[index++])];
         }
         return index && index == length ? object2 : undefined2;
       }
@@ -284401,10 +284401,10 @@ var require_lodash = __commonJS((exports, module) => {
         });
         return accumulator;
       }
-      function baseInvoke(object2, path76, args) {
-        path76 = castPath(path76, object2);
-        object2 = parent(object2, path76);
-        var func = object2 == null ? object2 : object2[toKey(last2(path76))];
+      function baseInvoke(object2, path77, args) {
+        path77 = castPath(path77, object2);
+        object2 = parent(object2, path77);
+        var func = object2 == null ? object2 : object2[toKey(last2(path77))];
         return func == null ? undefined2 : apply(func, object2, args);
       }
       function baseIsArguments(value) {
@@ -284560,13 +284560,13 @@ var require_lodash = __commonJS((exports, module) => {
           return object2 === source2 || baseIsMatch(object2, source2, matchData);
         };
       }
-      function baseMatchesProperty(path76, srcValue) {
-        if (isKey(path76) && isStrictComparable(srcValue)) {
-          return matchesStrictComparable(toKey(path76), srcValue);
+      function baseMatchesProperty(path77, srcValue) {
+        if (isKey(path77) && isStrictComparable(srcValue)) {
+          return matchesStrictComparable(toKey(path77), srcValue);
         }
         return function(object2) {
-          var objValue = get(object2, path76);
-          return objValue === undefined2 && objValue === srcValue ? hasIn(object2, path76) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+          var objValue = get(object2, path77);
+          return objValue === undefined2 && objValue === srcValue ? hasIn(object2, path77) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
         };
       }
       function baseMerge(object2, source2, srcIndex, customizer, stack) {
@@ -284663,23 +284663,23 @@ var require_lodash = __commonJS((exports, module) => {
         });
       }
       function basePick(object2, paths) {
-        return basePickBy(object2, paths, function(value, path76) {
-          return hasIn(object2, path76);
+        return basePickBy(object2, paths, function(value, path77) {
+          return hasIn(object2, path77);
         });
       }
       function basePickBy(object2, paths, predicate) {
         var index = -1, length = paths.length, result2 = {};
         while (++index < length) {
-          var path76 = paths[index], value = baseGet(object2, path76);
-          if (predicate(value, path76)) {
-            baseSet(result2, castPath(path76, object2), value);
+          var path77 = paths[index], value = baseGet(object2, path77);
+          if (predicate(value, path77)) {
+            baseSet(result2, castPath(path77, object2), value);
           }
         }
         return result2;
       }
-      function basePropertyDeep(path76) {
+      function basePropertyDeep(path77) {
         return function(object2) {
-          return baseGet(object2, path76);
+          return baseGet(object2, path77);
         };
       }
       function basePullAll(array2, values2, iteratee2, comparator) {
@@ -284753,14 +284753,14 @@ var require_lodash = __commonJS((exports, module) => {
         var array2 = values(collection);
         return shuffleSelf(array2, baseClamp(n, 0, array2.length));
       }
-      function baseSet(object2, path76, value, customizer) {
+      function baseSet(object2, path77, value, customizer) {
         if (!isObject3(object2)) {
           return object2;
         }
-        path76 = castPath(path76, object2);
-        var index = -1, length = path76.length, lastIndex = length - 1, nested = object2;
+        path77 = castPath(path77, object2);
+        var index = -1, length = path77.length, lastIndex = length - 1, nested = object2;
         while (nested != null && ++index < length) {
-          var key = toKey(path76[index]), newValue = value;
+          var key = toKey(path77[index]), newValue = value;
           if (key === "__proto__" || key === "constructor" || key === "prototype") {
             return object2;
           }
@@ -284768,7 +284768,7 @@ var require_lodash = __commonJS((exports, module) => {
             var objValue = nested[key];
             newValue = customizer ? customizer(objValue, key, nested) : undefined2;
             if (newValue === undefined2) {
-              newValue = isObject3(objValue) ? objValue : isIndex(path76[index + 1]) ? [] : {};
+              newValue = isObject3(objValue) ? objValue : isIndex(path77[index + 1]) ? [] : {};
             }
           }
           assignValue(nested, key, newValue);
@@ -284934,13 +284934,13 @@ var require_lodash = __commonJS((exports, module) => {
           }
         return result2;
       }
-      function baseUnset(object2, path76) {
-        path76 = castPath(path76, object2);
-        object2 = parent(object2, path76);
-        return object2 == null || delete object2[toKey(last2(path76))];
+      function baseUnset(object2, path77) {
+        path77 = castPath(path77, object2);
+        object2 = parent(object2, path77);
+        return object2 == null || delete object2[toKey(last2(path77))];
       }
-      function baseUpdate(object2, path76, updater, customizer) {
-        return baseSet(object2, path76, updater(baseGet(object2, path76)), customizer);
+      function baseUpdate(object2, path77, updater, customizer) {
+        return baseSet(object2, path77, updater(baseGet(object2, path77)), customizer);
       }
       function baseWhile(array2, predicate, isDrop, fromRight) {
         var length = array2.length, index = fromRight ? length : -1;
@@ -285799,11 +285799,11 @@ var require_lodash = __commonJS((exports, module) => {
         var match2 = source2.match(reWrapDetails);
         return match2 ? match2[1].split(reSplitDetails) : [];
       }
-      function hasPath(object2, path76, hasFunc) {
-        path76 = castPath(path76, object2);
-        var index = -1, length = path76.length, result2 = false;
+      function hasPath(object2, path77, hasFunc) {
+        path77 = castPath(path77, object2);
+        var index = -1, length = path77.length, result2 = false;
         while (++index < length) {
-          var key = toKey(path76[index]);
+          var key = toKey(path77[index]);
           if (!(result2 = object2 != null && hasFunc(object2, key))) {
             break;
           }
@@ -286007,8 +286007,8 @@ var require_lodash = __commonJS((exports, module) => {
           return apply(func, this, otherArgs);
         };
       }
-      function parent(object2, path76) {
-        return path76.length < 2 ? object2 : baseGet(object2, baseSlice(path76, 0, -1));
+      function parent(object2, path77) {
+        return path77.length < 2 ? object2 : baseGet(object2, baseSlice(path77, 0, -1));
       }
       function reorder(array2, indexes) {
         var arrLength = array2.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array2);
@@ -286641,10 +286641,10 @@ var require_lodash = __commonJS((exports, module) => {
         }
         return isString2(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
       }
-      var invokeMap = baseRest(function(collection, path76, args) {
-        var index = -1, isFunc = typeof path76 == "function", result2 = isArrayLike2(collection) ? Array2(collection.length) : [];
+      var invokeMap = baseRest(function(collection, path77, args) {
+        var index = -1, isFunc = typeof path77 == "function", result2 = isArrayLike2(collection) ? Array2(collection.length) : [];
         baseEach(collection, function(value) {
-          result2[++index] = isFunc ? apply(path76, value, args) : baseInvoke(value, path76, args);
+          result2[++index] = isFunc ? apply(path77, value, args) : baseInvoke(value, path77, args);
         });
         return result2;
       });
@@ -287296,15 +287296,15 @@ var require_lodash = __commonJS((exports, module) => {
       function functionsIn(object2) {
         return object2 == null ? [] : baseFunctions(object2, keysIn(object2));
       }
-      function get(object2, path76, defaultValue) {
-        var result2 = object2 == null ? undefined2 : baseGet(object2, path76);
+      function get(object2, path77, defaultValue) {
+        var result2 = object2 == null ? undefined2 : baseGet(object2, path77);
         return result2 === undefined2 ? defaultValue : result2;
       }
-      function has(object2, path76) {
-        return object2 != null && hasPath(object2, path76, baseHas);
+      function has(object2, path77) {
+        return object2 != null && hasPath(object2, path77, baseHas);
       }
-      function hasIn(object2, path76) {
-        return object2 != null && hasPath(object2, path76, baseHasIn);
+      function hasIn(object2, path77) {
+        return object2 != null && hasPath(object2, path77, baseHasIn);
       }
       var invert = createInverter(function(result2, value, key) {
         if (value != null && typeof value.toString != "function") {
@@ -287357,10 +287357,10 @@ var require_lodash = __commonJS((exports, module) => {
           return result2;
         }
         var isDeep = false;
-        paths = arrayMap(paths, function(path76) {
-          path76 = castPath(path76, object2);
-          isDeep || (isDeep = path76.length > 1);
-          return path76;
+        paths = arrayMap(paths, function(path77) {
+          path77 = castPath(path77, object2);
+          isDeep || (isDeep = path77.length > 1);
+          return path77;
         });
         copyObject(object2, getAllKeysIn(object2), result2);
         if (isDeep) {
@@ -287386,19 +287386,19 @@ var require_lodash = __commonJS((exports, module) => {
           return [prop];
         });
         predicate = getIteratee(predicate);
-        return basePickBy(object2, props, function(value, path76) {
-          return predicate(value, path76[0]);
+        return basePickBy(object2, props, function(value, path77) {
+          return predicate(value, path77[0]);
         });
       }
-      function result(object2, path76, defaultValue) {
-        path76 = castPath(path76, object2);
-        var index = -1, length = path76.length;
+      function result(object2, path77, defaultValue) {
+        path77 = castPath(path77, object2);
+        var index = -1, length = path77.length;
         if (!length) {
           length = 1;
           object2 = undefined2;
         }
         while (++index < length) {
-          var value = object2 == null ? undefined2 : object2[toKey(path76[index])];
+          var value = object2 == null ? undefined2 : object2[toKey(path77[index])];
           if (value === undefined2) {
             index = length;
             value = defaultValue;
@@ -287407,12 +287407,12 @@ var require_lodash = __commonJS((exports, module) => {
         }
         return object2;
       }
-      function set3(object2, path76, value) {
-        return object2 == null ? object2 : baseSet(object2, path76, value);
+      function set3(object2, path77, value) {
+        return object2 == null ? object2 : baseSet(object2, path77, value);
       }
-      function setWith(object2, path76, value, customizer) {
+      function setWith(object2, path77, value, customizer) {
         customizer = typeof customizer == "function" ? customizer : undefined2;
-        return object2 == null ? object2 : baseSet(object2, path76, value, customizer);
+        return object2 == null ? object2 : baseSet(object2, path77, value, customizer);
       }
       var toPairs = createToPairs(keys);
       var toPairsIn = createToPairs(keysIn);
@@ -287434,15 +287434,15 @@ var require_lodash = __commonJS((exports, module) => {
         });
         return accumulator;
       }
-      function unset(object2, path76) {
-        return object2 == null ? true : baseUnset(object2, path76);
+      function unset(object2, path77) {
+        return object2 == null ? true : baseUnset(object2, path77);
       }
-      function update4(object2, path76, updater) {
-        return object2 == null ? object2 : baseUpdate(object2, path76, castFunction(updater));
+      function update4(object2, path77, updater) {
+        return object2 == null ? object2 : baseUpdate(object2, path77, castFunction(updater));
       }
-      function updateWith(object2, path76, updater, customizer) {
+      function updateWith(object2, path77, updater, customizer) {
         customizer = typeof customizer == "function" ? customizer : undefined2;
-        return object2 == null ? object2 : baseUpdate(object2, path76, castFunction(updater), customizer);
+        return object2 == null ? object2 : baseUpdate(object2, path77, castFunction(updater), customizer);
       }
       function values(object2) {
         return object2 == null ? [] : baseValues(object2, keys(object2));
@@ -287837,17 +287837,17 @@ __p += '`;
       function matches(source2) {
         return baseMatches(baseClone(source2, CLONE_DEEP_FLAG));
       }
-      function matchesProperty(path76, srcValue) {
-        return baseMatchesProperty(path76, baseClone(srcValue, CLONE_DEEP_FLAG));
+      function matchesProperty(path77, srcValue) {
+        return baseMatchesProperty(path77, baseClone(srcValue, CLONE_DEEP_FLAG));
       }
-      var method = baseRest(function(path76, args) {
+      var method = baseRest(function(path77, args) {
         return function(object2) {
-          return baseInvoke(object2, path76, args);
+          return baseInvoke(object2, path77, args);
         };
       });
       var methodOf = baseRest(function(object2, args) {
-        return function(path76) {
-          return baseInvoke(object2, path76, args);
+        return function(path77) {
+          return baseInvoke(object2, path77, args);
         };
       });
       function mixin3(object2, source2, options) {
@@ -287893,12 +287893,12 @@ __p += '`;
       var over = createOver(arrayMap);
       var overEvery = createOver(arrayEvery);
       var overSome = createOver(arraySome);
-      function property(path76) {
-        return isKey(path76) ? baseProperty(toKey(path76)) : basePropertyDeep(path76);
+      function property(path77) {
+        return isKey(path77) ? baseProperty(toKey(path77)) : basePropertyDeep(path77);
       }
       function propertyOf(object2) {
-        return function(path76) {
-          return object2 == null ? undefined2 : baseGet(object2, path76);
+        return function(path77) {
+          return object2 == null ? undefined2 : baseGet(object2, path77);
         };
       }
       var range2 = createRange();
@@ -288351,12 +288351,12 @@ __p += '`;
       LazyWrapper.prototype.findLast = function(predicate) {
         return this.reverse().find(predicate);
       };
-      LazyWrapper.prototype.invokeMap = baseRest(function(path76, args) {
-        if (typeof path76 == "function") {
+      LazyWrapper.prototype.invokeMap = baseRest(function(path77, args) {
+        if (typeof path77 == "function") {
           return new LazyWrapper(this);
         }
         return this.map(function(value) {
-          return baseInvoke(value, path76, args);
+          return baseInvoke(value, path77, args);
         });
       });
       LazyWrapper.prototype.reject = function(predicate) {
@@ -288730,14 +288730,14 @@ function formatDuration(seconds) {
 }
 
 // src/commands/scenario/src/path-parser.ts
-function parseParameterPath(path76) {
-  if (pathCache.has(path76)) {
-    return pathCache.get(path76);
+function parseParameterPath(path77) {
+  if (pathCache.has(path77)) {
+    return pathCache.get(path77);
   }
-  if (!path76 || typeof path76 !== "string") {
+  if (!path77 || typeof path77 !== "string") {
     throw new Error("Path must be a non-empty string");
   }
-  if (path76.startsWith(".") || path76.endsWith(".")) {
+  if (path77.startsWith(".") || path77.endsWith(".")) {
     throw new Error("Path cannot start or end with a dot");
   }
   const segments = [];
@@ -288745,8 +288745,8 @@ function parseParameterPath(path76) {
   let currentSegment = "";
   let i2 = 0;
   let lastCharWasArrayClose = false;
-  while (i2 < path76.length) {
-    const char = path76[i2];
+  while (i2 < path77.length) {
+    const char = path77[i2];
     if (char === ".") {
       if (currentSegment === "" && !lastCharWasArrayClose) {
         throw new Error("Empty segment in path (double dots or leading/trailing dots not allowed)");
@@ -288763,11 +288763,11 @@ function parseParameterPath(path76) {
       }
       segments.push(currentSegment);
       currentSegment = "";
-      const closingBracket = path76.indexOf("]", i2);
+      const closingBracket = path77.indexOf("]", i2);
       if (closingBracket === -1) {
         throw new Error("Missing closing bracket for array index");
       }
-      const indexStr = path76.substring(i2 + 1, closingBracket);
+      const indexStr = path77.substring(i2 + 1, closingBracket);
       if (!/^\d+$/.test(indexStr)) {
         throw new Error(`Invalid array index: ${indexStr}`);
       }
@@ -288786,7 +288786,7 @@ function parseParameterPath(path76) {
   }
   if (currentSegment !== "") {
     segments.push(currentSegment);
-  } else if (path76.endsWith(".")) {
+  } else if (path77.endsWith(".")) {
     throw new Error("Path cannot start or end with a dot");
   }
   if (segments.length === 0) {
@@ -288802,24 +288802,24 @@ function parseParameterPath(path76) {
   const result = {
     segments,
     hasArrayAccess,
-    originalPath: path76
+    originalPath: path77
   };
-  pathCache.set(path76, result);
+  pathCache.set(path77, result);
   return result;
 }
-function isValidPathSyntax(path76) {
+function isValidPathSyntax(path77) {
   try {
-    parseParameterPath(path76);
+    parseParameterPath(path77);
     return true;
   } catch {
     return false;
   }
 }
-function normalizeParameterPath(path76) {
-  if (!path76 || typeof path76 !== "string") {
+function normalizeParameterPath(path77) {
+  if (!path77 || typeof path77 !== "string") {
     return "";
   }
-  let normalized = path76.trim();
+  let normalized = path77.trim();
   normalized = normalized.replace(/\.+/g, ".");
   normalized = normalized.replace(/^\.+|\.+$/g, "");
   return normalized;
@@ -288976,7 +288976,7 @@ __export(exports_parameter_override, {
   applyParameterOverride: () => applyParameterOverride,
   applyMatrixOverrides: () => applyMatrixOverrides
 });
-function validateParameterPath(obj, path76) {
+function validateParameterPath(obj, path77) {
   if (!obj || typeof obj !== "object") {
     return {
       isValid: false,
@@ -288986,7 +288986,7 @@ function validateParameterPath(obj, path76) {
     };
   }
   try {
-    const parsedPath = parseParameterPath(path76);
+    const parsedPath = parseParameterPath(path77);
     let current = obj;
     let currentPath = "";
     for (let i2 = 0;i2 < parsedPath.segments.length; i2++) {
@@ -289056,54 +289056,54 @@ function validateParameterPath(obj, path76) {
     };
   }
 }
-function validateParameterPathLegacy(obj, path76) {
-  const result = validateParameterPath(obj, path76);
+function validateParameterPathLegacy(obj, path77) {
+  const result = validateParameterPath(obj, path77);
   return result.isValid;
 }
-function getValueAtPath(obj, path76) {
-  const parsedPath = parseParameterPath(path76);
+function getValueAtPath(obj, path77) {
+  const parsedPath = parseParameterPath(path77);
   let current = obj;
   for (let i2 = 0;i2 < parsedPath.segments.length; i2++) {
     const segment = parsedPath.segments[i2];
     if (typeof segment === "number") {
       if (!Array.isArray(current)) {
-        throw new Error(`Expected array at path segment, but found ${typeof current} in path: ${path76}`);
+        throw new Error(`Expected array at path segment, but found ${typeof current} in path: ${path77}`);
       }
       if (segment >= current.length || segment < 0) {
-        throw new Error(`Array index out of bounds: ${segment} in path: ${path76}`);
+        throw new Error(`Array index out of bounds: ${segment} in path: ${path77}`);
       }
       current = current[segment];
     } else {
       if (!current || typeof current !== "object") {
-        throw new Error(`Expected object at path segment, but found ${typeof current} in path: ${path76}`);
+        throw new Error(`Expected object at path segment, but found ${typeof current} in path: ${path77}`);
       }
       if (!(segment in current)) {
-        throw new Error(`Property '${segment}' not found in path: ${path76}`);
+        throw new Error(`Property '${segment}' not found in path: ${path77}`);
       }
       current = current[segment];
     }
   }
   return current;
 }
-function setValueAtPath(obj, path76, value) {
-  const parsedPath = parseParameterPath(path76);
+function setValueAtPath(obj, path77, value) {
+  const parsedPath = parseParameterPath(path77);
   let current = obj;
   for (let i2 = 0;i2 < parsedPath.segments.length - 1; i2++) {
     const segment = parsedPath.segments[i2];
     if (typeof segment === "number") {
       if (!Array.isArray(current)) {
-        throw new Error(`Expected array at path segment, but found ${typeof current} in path: ${path76}`);
+        throw new Error(`Expected array at path segment, but found ${typeof current} in path: ${path77}`);
       }
       if (segment >= current.length || segment < 0) {
-        throw new Error(`Array index out of bounds: ${segment} in path: ${path76}`);
+        throw new Error(`Array index out of bounds: ${segment} in path: ${path77}`);
       }
       current = current[segment];
     } else {
       if (!current || typeof current !== "object") {
-        throw new Error(`Expected object at path segment, but found ${typeof current} in path: ${path76}`);
+        throw new Error(`Expected object at path segment, but found ${typeof current} in path: ${path77}`);
       }
       if (!(segment in current)) {
-        throw new Error(`Property '${segment}' not found in path: ${path76}`);
+        throw new Error(`Property '${segment}' not found in path: ${path77}`);
       }
       current = current[segment];
     }
@@ -289111,27 +289111,27 @@ function setValueAtPath(obj, path76, value) {
   const finalSegment = parsedPath.segments[parsedPath.segments.length - 1];
   if (typeof finalSegment === "number") {
     if (!Array.isArray(current)) {
-      throw new Error(`Expected array for final segment, but found ${typeof current} in path: ${path76}`);
+      throw new Error(`Expected array for final segment, but found ${typeof current} in path: ${path77}`);
     }
     if (finalSegment >= current.length || finalSegment < 0) {
-      throw new Error(`Array index out of bounds: ${finalSegment} in path: ${path76}`);
+      throw new Error(`Array index out of bounds: ${finalSegment} in path: ${path77}`);
     }
     current[finalSegment] = value;
   } else {
     if (!current || typeof current !== "object") {
-      throw new Error(`Expected object for final segment, but found ${typeof current} in path: ${path76}`);
+      throw new Error(`Expected object for final segment, but found ${typeof current} in path: ${path77}`);
     }
     current[finalSegment] = value;
   }
 }
-function applyParameterOverride(scenario, path76, value) {
+function applyParameterOverride(scenario, path77, value) {
   const clonedScenario = deepClone(scenario);
-  setValueAtPath(clonedScenario, path76, value);
+  setValueAtPath(clonedScenario, path77, value);
   return clonedScenario;
 }
 function applyMatrixOverrides(baseScenario, overrides) {
-  const parameterOverrides = Object.entries(overrides).map(([path76, value]) => ({
-    path: path76,
+  const parameterOverrides = Object.entries(overrides).map(([path77, value]) => ({
+    path: path77,
     value
   }));
   return applyParameterOverrides(baseScenario, parameterOverrides);
@@ -289189,8 +289189,8 @@ function applyParameterOverrides(baseScenario, overrides) {
   return modifiedScenario;
 }
 function combinationToOverrides(combination) {
-  return Object.entries(combination).map(([path76, value]) => ({
-    path: path76,
+  return Object.entries(combination).map(([path77, value]) => ({
+    path: path77,
     value
   }));
 }
@@ -289294,16 +289294,16 @@ async function ensureIsolatedDatabase(dbPath) {
 async function writeTemporaryScenario(scenarioPath, baseScenario, parameters) {
   try {
     const modifiedScenario = JSON.parse(JSON.stringify(baseScenario));
-    for (const [path76, value] of Object.entries(parameters)) {
-      setNestedProperty(modifiedScenario, path76, value);
+    for (const [path77, value] of Object.entries(parameters)) {
+      setNestedProperty(modifiedScenario, path77, value);
     }
     await fs52.writeFile(scenarioPath, JSON.stringify(modifiedScenario, null, 2));
   } catch (error47) {
     throw new Error(`Failed to write temporary scenario: ${error47 instanceof Error ? error47.message : String(error47)}`);
   }
 }
-function setNestedProperty(obj, path76, value) {
-  const keys = path76.split(".");
+function setNestedProperty(obj, path77, value) {
+  const keys = path77.split(".");
   let current = obj;
   for (let i2 = 0;i2 < keys.length - 1; i2++) {
     const key = keys[i2];
@@ -289969,8 +289969,8 @@ async function calculateDiskUsage(dirPath) {
         stdout: "pipe",
         stderr: "pipe"
       });
-      const output2 = await new Response(proc6.stdout).text();
-      const lines = output2.split(`
+      const output3 = await new Response(proc6.stdout).text();
+      const lines = output3.split(`
 `);
       const freeBytes = parseInt(lines[0].split(":")[1].trim());
       const totalBytes = parseInt(lines[1].split(":")[1].trim());
@@ -289990,8 +289990,8 @@ async function calculateDiskUsage(dirPath) {
         stdout: "pipe",
         stderr: "pipe"
       });
-      const output2 = await new Response(proc6.stdout).text();
-      const lines = output2.split(`
+      const output3 = await new Response(proc6.stdout).text();
+      const lines = output3.split(`
 `);
       const data = lines[1].split(/\s+/);
       const totalKB = parseInt(data[1]);
@@ -316250,25 +316250,218 @@ ${emoji.error("Error: Failed to run Phala CLI")}`);
   console.log("  $ npx phala help");
 });
 
+// src/commands/tee/eigen-wrapper.ts
+init_esm();
+init_emoji_handler();
+init_bun_exec();
+import { logger as logger49 } from "@elizaos/core";
+import readline3 from "readline/promises";
+import { stdin as input2, stdout as output2 } from "process";
+import path69 from "path";
+var findRawArgs = (cmd) => {
+  const commandWithRawArgs = cmd;
+  const parentRawArgs = commandWithRawArgs.parent?.rawArgs;
+  if (Array.isArray(parentRawArgs)) {
+    return parentRawArgs;
+  }
+  if (Array.isArray(commandWithRawArgs.rawArgs)) {
+    return commandWithRawArgs.rawArgs;
+  }
+  return process.argv;
+};
+var sliceArgsAfterSubcommand = (rawArgs, subcommand) => {
+  const subcommandIndex = rawArgs.findIndex((arg) => arg === subcommand);
+  if (subcommandIndex >= 0) {
+    return rawArgs.slice(subcommandIndex + 1);
+  }
+  return [];
+};
+var eigenCliCommand = new Command("eigen").description("Eigen CLI - Manage TEE deployments on Eigen infrastructure").allowUnknownOption().helpOption(false).allowExcessArguments(true).passThroughOptions().argument("[args...]", "All arguments to pass to the Eigen CLI").action(async (...commandArgs) => {
+  const cmd = commandArgs[commandArgs.length - 1];
+  const rawArgs = findRawArgs(cmd);
+  const argsFromRaw = sliceArgsAfterSubcommand(rawArgs, "eigen");
+  const args = argsFromRaw.length > 0 ? argsFromRaw : Array.isArray(commandArgs[0]) ? commandArgs[0] : [];
+  const candidateBinaries = (() => {
+    const candidates = new Set;
+    const fromEnv = process.env.EIGENX_BIN;
+    if (fromEnv && fromEnv.trim().length > 0) {
+      candidates.add(fromEnv);
+    }
+    candidates.add("eigenx");
+    candidates.add("eigenx-dev");
+    const home = process.env.HOME;
+    if (home) {
+      const potentialDirs = [
+        path69.join(home, "bin"),
+        path69.join(home, ".local", "bin"),
+        path69.join(home, ".eigenx", "bin")
+      ];
+      for (const dir of potentialDirs) {
+        candidates.add(path69.join(dir, "eigenx"));
+        candidates.add(path69.join(dir, "eigenx-dev"));
+      }
+    }
+    const commonDirs = ["/usr/local/bin", "/usr/bin", "/opt/homebrew/bin"];
+    for (const dir of commonDirs) {
+      candidates.add(path69.join(dir, "eigenx"));
+      candidates.add(path69.join(dir, "eigenx-dev"));
+    }
+    return Array.from(candidates);
+  })();
+  const resolveCandidate = async (candidate) => {
+    if (path69.isAbsolute(candidate)) {
+      try {
+        const file2 = Bun.file(candidate);
+        const exists = await file2.exists();
+        if (exists) {
+          return { command: candidate, additionalPath: path69.dirname(candidate) };
+        }
+      } catch {}
+      return null;
+    }
+    if (await commandExists(candidate)) {
+      return { command: candidate };
+    }
+    return null;
+  };
+  const ensureEigenCli = async () => {
+    for (const candidate of candidateBinaries) {
+      const resolved = await resolveCandidate(candidate);
+      if (resolved) {
+        return resolved;
+      }
+    }
+    return null;
+  };
+  let resolvedBinary = await ensureEigenCli();
+  if (!resolvedBinary) {
+    logger49.warn("Eigen CLI binary not found in PATH.");
+    logger49.warn("Attempting to install the Eigen CLI with user consent.");
+    const autoInstall = process.env.ELIZA_TEE_EIGEN_AUTO_INSTALL === "true";
+    const isInteractive2 = process.stdin.isTTY && process.stdout.isTTY;
+    if (!autoInstall && !isInteractive2) {
+      logger49.error(`
+${emoji.error("Error: Eigen CLI not installed and cannot prompt in non-interactive mode.")}`);
+      logger49.error("   Install manually:");
+      logger49.error("   curl -fsSL https://eigenx-scripts.s3.us-east-1.amazonaws.com/install-eigenx.sh | bash");
+      process.exit(1);
+      return;
+    }
+    let userConsent = autoInstall;
+    if (!autoInstall) {
+      const rl = readline3.createInterface({ input: input2, output: output2 });
+      console.log("");
+      console.log("Eigen CLI Installer");
+      console.log("  This will download and install the Eigen CLI by running:");
+      console.log("  curl -fsSL https://eigenx-scripts.s3.us-east-1.amazonaws.com/install-eigenx.sh | bash");
+      console.log("");
+      console.log("The script adds eigenx binaries (eigenx, eigenx-dev) to your PATH.");
+      console.log("");
+      const answer = (await rl.question("Proceed with Eigen CLI installation? [y/N] ")).trim().toLowerCase();
+      rl.close();
+      userConsent = answer === "y" || answer === "yes";
+    }
+    if (!userConsent) {
+      logger49.error(`
+${emoji.error("Eigen CLI installation is required to run this command.")}`);
+      logger49.error("   Installation can be performed at any time using:");
+      logger49.error("   curl -fsSL https://eigenx-scripts.s3.us-east-1.amazonaws.com/install-eigenx.sh | bash");
+      process.exit(1);
+      return;
+    }
+    const curlAvailable = await commandExists("curl");
+    if (!curlAvailable) {
+      logger49.error(`
+${emoji.error("Error: curl is required to install the Eigen CLI.")}`);
+      logger49.error("   Please install curl and try again.");
+      process.exit(1);
+      return;
+    }
+    logger49.info("Installing Eigen CLI...");
+    try {
+      await bunExecInherit("bash", [
+        "-c",
+        "curl -fsSL https://eigenx-scripts.s3.us-east-1.amazonaws.com/install-eigenx.sh | bash"
+      ]);
+    } catch (error47) {
+      logger49.error({ error: error47 }, "Eigen CLI installation failed");
+      logger49.error("   Please review the output above for details.");
+      process.exit(1);
+      return;
+    }
+    resolvedBinary = await ensureEigenCli();
+    if (!resolvedBinary) {
+      logger49.error(`
+${emoji.error("Error: Eigen CLI installation completed, but binary not found in PATH.")}`);
+      logger49.error("   Ensure your PATH includes the location where eigenx was installed.");
+      process.exit(1);
+      return;
+    }
+    logger49.info({ binary: resolvedBinary.command }, "Eigen CLI installation completed successfully.");
+  }
+  const prependPathEntries = [];
+  if (resolvedBinary.additionalPath) {
+    prependPathEntries.push(resolvedBinary.additionalPath);
+  }
+  if (process.env.ELIZA_TEE_EIGEN_EXTRA_PATHS) {
+    const extraPaths = process.env.ELIZA_TEE_EIGEN_EXTRA_PATHS.split(path69.delimiter).map((p2) => p2.trim()).filter((p2) => p2.length > 0);
+    prependPathEntries.push(...extraPaths);
+  }
+  const envOverride = (() => {
+    if (prependPathEntries.length === 0) {
+      return;
+    }
+    const existingPath = process.env.PATH ?? "";
+    const combined = [...prependPathEntries, existingPath].filter((entry) => entry.length > 0).join(path69.delimiter);
+    return { PATH: combined };
+  })();
+  logger49.info({ args, binary: resolvedBinary.command }, "Running Eigen CLI command");
+  try {
+    const result = await bunExecInherit(resolvedBinary.command, args, envOverride ? { env: envOverride } : {});
+    process.exit(result.exitCode ?? 0);
+  } catch (error47) {
+    logger49.error({ error: error47, args, binary: resolvedBinary.command }, "Failed to execute Eigen CLI");
+    process.exit(1);
+  }
+}).configureHelp({
+  helpWidth: 100
+}).on("--help", () => {
+  console.log("");
+  console.log("This command wraps the official Eigen CLI (eigenx).");
+  console.log("Ensure the Eigen CLI binary is installed and available on your PATH.");
+  console.log("All arguments are passed directly to the Eigen CLI.");
+  console.log("");
+  console.log("Examples:");
+  console.log("  $ elizaos tee eigen help");
+  console.log("  $ elizaos tee eigen app list");
+  console.log("  $ elizaos tee eigen app deploy myregistry/myapp:v1.0");
+  console.log("");
+  console.log("For full Eigen CLI documentation, run:");
+  console.log("  $ eigenx help");
+  console.log("");
+  console.log("Installation:");
+  console.log("  $ curl -fsSL https://eigenx-scripts.s3.us-east-1.amazonaws.com/install-eigenx.sh | bash");
+});
+
 // src/commands/tee/index.ts
-var teeCommand = new Command("tee").description("Manage TEE deployments").enablePositionalOptions().addCommand(phalaCliCommand);
+var teeCommand = new Command("tee").description("Manage TEE deployments").enablePositionalOptions().addCommand(phalaCliCommand).addCommand(eigenCliCommand);
 
 // src/commands/test/index.ts
 init_utils();
 init_esm();
-import { logger as logger55 } from "@elizaos/core";
+import { logger as logger56 } from "@elizaos/core";
 
 // src/commands/test/actions/run-all-tests.ts
-import { logger as logger53 } from "@elizaos/core";
+import { logger as logger54 } from "@elizaos/core";
 
 // src/commands/test/utils/project-utils.ts
 init_directory_detection();
 init_run_bun();
-import { logger as logger49 } from "@elizaos/core";
+import { logger as logger50 } from "@elizaos/core";
 import * as fs46 from "fs";
-import path69 from "path";
+import path70 from "path";
 function getProjectType(testPath) {
-  const targetPath = testPath ? path69.resolve(process.cwd(), testPath) : process.cwd();
+  const targetPath = testPath ? path70.resolve(process.cwd(), testPath) : process.cwd();
   return detectDirectoryType(targetPath);
 }
 function processFilterName(name2) {
@@ -316288,11 +316481,11 @@ async function installPluginDependencies(projectInfo) {
   }
   const project = await loadProject(process.cwd());
   if (project.isPlugin && project.pluginModule?.dependencies && project.pluginModule.dependencies.length > 0) {
-    const pluginsDir = path69.join(process.cwd(), ".eliza", "plugins");
+    const pluginsDir = path70.join(process.cwd(), ".eliza", "plugins");
     if (!fs46.existsSync(pluginsDir)) {
       await fs46.promises.mkdir(pluginsDir, { recursive: true });
     }
-    const packageJsonPath = path69.join(pluginsDir, "package.json");
+    const packageJsonPath = path70.join(pluginsDir, "package.json");
     if (!fs46.existsSync(packageJsonPath)) {
       const packageJsonContent = {
         name: "test-plugin-dependencies",
@@ -316305,12 +316498,12 @@ async function installPluginDependencies(projectInfo) {
     const { installPlugin: installPlugin2 } = await Promise.resolve().then(() => (init_utils(), exports_utils));
     for (const dependency of project.pluginModule.dependencies) {
       await installPlugin2(dependency, pluginsDir);
-      const dependencyPath = path69.join(pluginsDir, "node_modules", dependency);
+      const dependencyPath = path70.join(pluginsDir, "node_modules", dependency);
       if (fs46.existsSync(dependencyPath)) {
         try {
           await runBunCommand(["install"], dependencyPath);
         } catch (error47) {
-          logger49.warn(`[Test Command] Failed to install devDependencies for ${dependency}: ${error47}`);
+          logger50.warn(`[Test Command] Failed to install devDependencies for ${dependency}: ${error47}`);
         }
       }
     }
@@ -316320,16 +316513,16 @@ async function installPluginDependencies(projectInfo) {
 // src/commands/test/actions/component-tests.ts
 init_utils();
 init_bun_exec();
-import { logger as logger51 } from "@elizaos/core";
-import path71 from "path";
+import { logger as logger52 } from "@elizaos/core";
+import path72 from "path";
 
 // src/utils/testing/tsc-validator.ts
 init_bun_exec();
-import { logger as logger50 } from "@elizaos/core";
-import path70 from "path";
+import { logger as logger51 } from "@elizaos/core";
+import path71 from "path";
 import { existsSync as existsSync44 } from "fs";
 async function runTypeCheck(projectPath, strict = true) {
-  const tsconfigPath = path70.join(projectPath, "tsconfig.json");
+  const tsconfigPath = path71.join(projectPath, "tsconfig.json");
   if (!existsSync44(tsconfigPath)) {
     return {
       success: false,
@@ -316353,7 +316546,7 @@ async function runTypeCheck(projectPath, strict = true) {
       warnings: stderr.includes("warning") ? [stderr] : []
     };
   } catch (error47) {
-    logger50.error({ error: error47 }, "TypeScript validation failed:");
+    logger51.error({ error: error47 }, "TypeScript validation failed:");
     return {
       success: false,
       errors: [`TypeScript validation error: ${error47.message}`],
@@ -316367,38 +316560,38 @@ async function runComponentTests(testPath, options, projectInfo) {
   const cwd = process.cwd();
   const isPlugin2 = projectInfo.type === "elizaos-plugin";
   if (!options.skipTypeCheck) {
-    logger51.info("Running TypeScript validation...");
+    logger52.info("Running TypeScript validation...");
     const typeCheckResult = await runTypeCheck(cwd, true);
     if (!typeCheckResult.success) {
-      logger51.error("TypeScript validation failed:");
-      typeCheckResult.errors.forEach((error47) => logger51.error(error47));
+      logger52.error("TypeScript validation failed:");
+      typeCheckResult.errors.forEach((error47) => logger52.error(error47));
       return { failed: true };
     }
-    logger51.success("TypeScript validation passed");
+    logger52.success("TypeScript validation passed");
   }
   if (!options.skipBuild) {
     try {
-      logger51.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
+      logger52.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
       await buildProject(cwd, isPlugin2);
-      logger51.success(`Build completed successfully`);
+      logger52.success(`Build completed successfully`);
     } catch (buildError) {
-      logger51.error(`Build failed: ${buildError}`);
+      logger52.error(`Build failed: ${buildError}`);
       return { failed: true };
     }
   }
-  logger51.info("Running component tests...");
+  logger52.info("Running component tests...");
   const args = ["test", "--passWithNoTests"];
   if (options.name) {
     const baseName = processFilterName(options.name);
     if (baseName) {
-      logger51.info(`Using test filter: ${baseName}`);
+      logger52.info(`Using test filter: ${baseName}`);
       args.push("-t", baseName);
     }
   }
   const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
   const baseDir = monorepoRoot ?? process.cwd();
-  const targetPath = testPath ? path71.resolve(baseDir, testPath) : process.cwd();
-  logger51.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
+  const targetPath = testPath ? path72.resolve(baseDir, testPath) : process.cwd();
+  logger52.info(`Executing: bun ${args.join(" ")} in ${targetPath}`);
   try {
     const result = await bunExecInherit("bun", args, {
       cwd: targetPath,
@@ -316407,10 +316600,10 @@ async function runComponentTests(testPath, options, projectInfo) {
         CI: ""
       }
     });
-    logger51.info("Component tests completed");
+    logger52.info("Component tests completed");
     return { failed: !result.success };
   } catch (error47) {
-    logger51.error({ error: error47 }, "Error running component tests:");
+    logger52.error({ error: error47 }, "Error running component tests:");
     return { failed: true };
   }
 }
@@ -316419,20 +316612,20 @@ async function runComponentTests(testPath, options, projectInfo) {
 init_utils();
 init_module_loader();
 var dotenv6 = __toESM(require_main(), 1);
-import { logger as logger52 } from "@elizaos/core";
+import { logger as logger53 } from "@elizaos/core";
 import * as fs47 from "fs";
-import path72 from "path";
+import path73 from "path";
 async function runE2eTests(testPath, options, projectInfo) {
   if (!options.skipBuild) {
     try {
       const cwd = process.cwd();
       const isPlugin2 = projectInfo.type === "elizaos-plugin";
-      logger52.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
+      logger53.info(`Building ${isPlugin2 ? "plugin" : "project"}...`);
       await buildProject(cwd, isPlugin2);
-      logger52.info(`Build completed successfully`);
+      logger53.info(`Build completed successfully`);
     } catch (buildError) {
-      logger52.error(`Build error: ${buildError}`);
-      logger52.warn(`Attempting to continue with tests despite build error`);
+      logger53.error(`Build error: ${buildError}`);
+      logger53.warn(`Attempting to continue with tests despite build error`);
     }
   }
   let server2;
@@ -316442,10 +316635,10 @@ async function runE2eTests(testPath, options, projectInfo) {
     const moduleLoader = getModuleLoader();
     const serverModule = await moduleLoader.load("@elizaos/server");
     const { AgentServer, jsonToCharacter, loadCharacterTryPath } = serverModule;
-    const elizaDir = path72.join(process.cwd(), ".eliza");
-    const packageName = path72.basename(process.cwd());
+    const elizaDir = path73.join(process.cwd(), ".eliza");
+    const packageName = path73.basename(process.cwd());
     const timestamp = Date.now();
-    const uniqueDbDir = path72.join(process.cwd(), ".elizadb-test", `${packageName}-${timestamp}`);
+    const uniqueDbDir = path73.join(process.cwd(), ".elizadb-test", `${packageName}-${timestamp}`);
     const elizaDbDir = uniqueDbDir;
     const envInfo = await UserEnvironment.getInstanceInfo();
     const envFilePath = envInfo.paths.envFilePath;
@@ -316469,74 +316662,74 @@ async function runE2eTests(testPath, options, projectInfo) {
     process.env.PGLITE_DATA_DIR = elizaDbDir;
     console.info(`Set PGLITE_DATA_DIR to: ${elizaDbDir}`);
     if (fs47.existsSync(envFilePath)) {
-      logger52.info(`Loading environment variables from: ${envFilePath}`);
+      logger53.info(`Loading environment variables from: ${envFilePath}`);
       dotenv6.config({ path: envFilePath });
-      logger52.info("Environment variables loaded");
+      logger53.info("Environment variables loaded");
     } else {
-      logger52.warn(`Environment file not found: ${envFilePath}`);
+      logger53.warn(`Environment file not found: ${envFilePath}`);
     }
     const postgresUrl = process.env.POSTGRES_URL;
-    logger52.info(`PostgreSQL URL for e2e tests: ${postgresUrl ? "found" : "not found (will use PGlite)"}`);
-    logger52.info("Creating server instance...");
+    logger53.info(`PostgreSQL URL for e2e tests: ${postgresUrl ? "found" : "not found (will use PGlite)"}`);
+    logger53.info("Creating server instance...");
     server2 = new AgentServer;
-    logger52.info("Server instance created");
-    logger52.info("Initializing server...");
+    logger53.info("Server instance created");
+    logger53.info("Initializing server...");
     try {
       await server2.initialize({
         dataDir: elizaDbDir,
         postgresUrl
       });
-      logger52.info("Server initialized successfully");
+      logger53.info("Server initialized successfully");
     } catch (initError) {
-      logger52.error({ error: initError }, "Server initialization failed:");
+      logger53.error({ error: initError }, "Server initialization failed:");
       throw initError;
     }
     let project;
     try {
-      logger52.info("Attempting to load project or plugin...");
+      logger53.info("Attempting to load project or plugin...");
       const monorepoRoot = UserEnvironment.getInstance().findMonorepoRoot(process.cwd());
       const baseDir = monorepoRoot ?? process.cwd();
-      const targetPath = testPath ? path72.resolve(baseDir, testPath) : process.cwd();
+      const targetPath = testPath ? path73.resolve(baseDir, testPath) : process.cwd();
       project = await loadProject(targetPath);
       if (!project) {
         throw new Error("Failed to load project");
       }
       if (!project.isPlugin && (!project.agents || project.agents.length === 0)) {
-        logger52.warn("No agents found in project configuration; falling back to default Eliza character for tests.");
+        logger53.warn("No agents found in project configuration; falling back to default Eliza character for tests.");
       }
-      logger52.info(`Found ${project.agents?.length || 0} agents`);
-      logger52.info("Setting up server properties...");
+      logger53.info(`Found ${project.agents?.length || 0} agents`);
+      logger53.info("Setting up server properties...");
       server2.startAgent = async (character) => {
-        logger52.info(`Starting agent for character ${character.name}`);
+        logger53.info(`Starting agent for character ${character.name}`);
         const runtimes2 = await server2.startAgents([character], [], { isTestMode: true });
         return runtimes2[0];
       };
       server2.loadCharacterTryPath = loadCharacterTryPath;
       server2.jsonToCharacter = jsonToCharacter;
-      logger52.info("Server properties set up");
+      logger53.info("Server properties set up");
       const desiredPort = options.port || Number.parseInt(process.env.SERVER_PORT || "3000");
       const serverHost = process.env.SERVER_HOST || "0.0.0.0";
       const serverPort = await findNextAvailablePort(desiredPort, serverHost);
       if (serverPort !== desiredPort) {
-        logger52.warn(`Port ${desiredPort} is in use for testing, using port ${serverPort} instead.`);
+        logger53.warn(`Port ${desiredPort} is in use for testing, using port ${serverPort} instead.`);
       }
-      logger52.info("Starting server...");
+      logger53.info("Starting server...");
       try {
         await server2.start(serverPort);
-        logger52.info({ serverPort }, "Server started successfully on port");
+        logger53.info({ serverPort }, "Server started successfully on port");
       } catch (error47) {
-        logger52.error({ error: error47 }, "Error starting server:");
+        logger53.error({ error: error47 }, "Error starting server:");
         if (error47 instanceof Error) {
-          logger52.error({ message: error47.message }, "Error details:");
-          logger52.error({ stack: error47.stack }, "Stack trace:");
+          logger53.error({ message: error47.message }, "Error details:");
+          logger53.error({ stack: error47.stack }, "Stack trace:");
         }
         throw error47;
       }
       try {
-        logger52.info(`Found ${project.agents.length} agents in ${project.isPlugin ? "plugin" : "project"}`);
+        logger53.info(`Found ${project.agents.length} agents in ${project.isPlugin ? "plugin" : "project"}`);
         if (project.isPlugin || (project.agents?.length || 0) === 0) {
           process.env.ELIZA_TESTING_PLUGIN = "true";
-          logger52.info("Using default Eliza character as test agent");
+          logger53.info("Using default Eliza character as test agent");
           try {
             const pluginUnderTest = project.pluginModule;
             if (!pluginUnderTest) {
@@ -316550,48 +316743,48 @@ async function runE2eTests(testPath, options, projectInfo) {
               character: defaultElizaCharacter,
               plugins: runtime.plugins
             });
-            logger52.info("Default test agent started successfully");
+            logger53.info("Default test agent started successfully");
           } catch (pluginError) {
-            logger52.error({ error: pluginError }, `Error starting plugin test agent:`);
+            logger53.error({ error: pluginError }, `Error starting plugin test agent:`);
             throw pluginError;
           }
         } else {
           for (const agent2 of project.agents) {
             try {
               const originalCharacter = { ...agent2.character };
-              logger52.debug(`Starting agent: ${originalCharacter.name}`);
+              logger53.debug(`Starting agent: ${originalCharacter.name}`);
               const startedRuntimes = await server2.startAgents([originalCharacter], agent2.plugins || [], { isTestMode: true });
               const runtime = startedRuntimes[0];
               if (agent2.init) {
-                logger52.debug(`Running custom init for agent: ${originalCharacter.name}`);
+                logger53.debug(`Running custom init for agent: ${originalCharacter.name}`);
                 await agent2.init(runtime);
               }
               runtimes.push(runtime);
               projectAgents.push(agent2);
               await new Promise((resolve14) => setTimeout(resolve14, 1000));
             } catch (agentError) {
-              logger52.error({ error: agentError, agentName: agent2.character.name }, "Error starting agent");
+              logger53.error({ error: agentError, agentName: agent2.character.name }, "Error starting agent");
               if (agentError instanceof Error) {
-                logger52.error({ message: agentError.message }, "Error details:");
-                logger52.error({ stack: agentError.stack }, "Stack trace:");
+                logger53.error({ message: agentError.message }, "Error details:");
+                logger53.error({ stack: agentError.stack }, "Stack trace:");
               }
-              logger52.warn(`Skipping agent ${agent2.character.name} due to startup error`);
+              logger53.warn(`Skipping agent ${agent2.character.name} due to startup error`);
             }
           }
         }
         if (runtimes.length === 0) {
           throw new Error("Failed to start any agents from project");
         }
-        logger52.debug(`Successfully started ${runtimes.length} agents for testing`);
+        logger53.debug(`Successfully started ${runtimes.length} agents for testing`);
         let totalFailed = 0;
         let anyTestsFound = false;
         for (let i = 0;i < runtimes.length; i++) {
           const runtime = runtimes[i];
           const projectAgent = projectAgents[i];
           if (project.isPlugin) {
-            logger52.debug(`Running tests for plugin: ${project.pluginModule?.name}`);
+            logger53.debug(`Running tests for plugin: ${project.pluginModule?.name}`);
           } else {
-            logger52.debug(`Running tests for agent: ${runtime.character.name}`);
+            logger53.debug(`Running tests for agent: ${runtime.character.name}`);
           }
           const testRunner = new TestRunner(runtime, projectAgent);
           const currentDirInfo = projectInfo;
@@ -316609,17 +316802,17 @@ async function runE2eTests(testPath, options, projectInfo) {
         }
         return { failed: anyTestsFound ? totalFailed > 0 : false };
       } catch (error47) {
-        logger52.error({ error: error47 }, "Error in runE2eTests:");
+        logger53.error({ error: error47 }, "Error in runE2eTests:");
         if (error47 instanceof Error) {
-          logger52.error({ message: error47.message }, "Error details:");
-          logger52.error({ stack: error47.stack }, "Stack trace:");
+          logger53.error({ message: error47.message }, "Error details:");
+          logger53.error({ stack: error47.stack }, "Stack trace:");
         } else {
-          logger52.error({ type: typeof error47 }, "Unknown error type:");
-          logger52.error({ error: error47 }, "Error value:");
+          logger53.error({ type: typeof error47 }, "Unknown error type:");
+          logger53.error({ error: error47 }, "Error value:");
           try {
-            logger52.error({ stringified: JSON.stringify(error47, null, 2) }, "Stringified error:");
+            logger53.error({ stringified: JSON.stringify(error47, null, 2) }, "Stringified error:");
           } catch (e2) {
-            logger52.error({ error: e2 }, "Could not stringify error:");
+            logger53.error({ error: e2 }, "Could not stringify error:");
           }
         }
         return { failed: true };
@@ -316633,7 +316826,7 @@ async function runE2eTests(testPath, options, projectInfo) {
             fs47.rmSync(elizaDbDir, { recursive: true, force: true });
             console.info(`Successfully cleaned up test database directory`);
           }
-          const testDir = path72.dirname(elizaDbDir);
+          const testDir = path73.dirname(elizaDbDir);
           if (fs47.existsSync(testDir) && fs47.readdirSync(testDir).length === 0) {
             fs47.rmSync(testDir, { recursive: true, force: true });
           }
@@ -316642,33 +316835,33 @@ async function runE2eTests(testPath, options, projectInfo) {
         }
       }
     } catch (error47) {
-      logger52.error({ error: error47 }, "Error in runE2eTests:");
+      logger53.error({ error: error47 }, "Error in runE2eTests:");
       if (error47 instanceof Error) {
-        logger52.error({ message: error47.message }, "Error details:");
-        logger52.error({ stack: error47.stack }, "Stack trace:");
+        logger53.error({ message: error47.message }, "Error details:");
+        logger53.error({ stack: error47.stack }, "Stack trace:");
       } else {
-        logger52.error({ type: typeof error47 }, "Unknown error type:");
-        logger52.error({ error: error47 }, "Error value:");
+        logger53.error({ type: typeof error47 }, "Unknown error type:");
+        logger53.error({ error: error47 }, "Error value:");
         try {
-          logger52.error({ stringified: JSON.stringify(error47, null, 2) }, "Stringified error:");
+          logger53.error({ stringified: JSON.stringify(error47, null, 2) }, "Stringified error:");
         } catch (e2) {
-          logger52.error({ error: e2 }, "Could not stringify error:");
+          logger53.error({ error: e2 }, "Could not stringify error:");
         }
       }
       return { failed: true };
     }
   } catch (error47) {
-    logger52.error({ error: error47 }, "Error in runE2eTests:");
+    logger53.error({ error: error47 }, "Error in runE2eTests:");
     if (error47 instanceof Error) {
-      logger52.error({ message: error47.message }, "Error details:");
-      logger52.error({ stack: error47.stack }, "Stack trace:");
+      logger53.error({ message: error47.message }, "Error details:");
+      logger53.error({ stack: error47.stack }, "Stack trace:");
     } else {
-      logger52.error({ type: typeof error47 }, "Unknown error type:");
-      logger52.error({ error: error47 }, "Error value:");
+      logger53.error({ type: typeof error47 }, "Unknown error type:");
+      logger53.error({ error: error47 }, "Error value:");
       try {
-        logger52.error({ stringified: JSON.stringify(error47, null, 2) }, "Stringified error:");
+        logger53.error({ stringified: JSON.stringify(error47, null, 2) }, "Stringified error:");
       } catch (e2) {
-        logger52.error({ error: e2 }, "Could not stringify error:");
+        logger53.error({ error: e2 }, "Could not stringify error:");
       }
     }
     return { failed: true };
@@ -316682,24 +316875,24 @@ async function runAllTests(testPath, options) {
   if (!options.skipBuild) {
     componentResult = await runComponentTests(testPath, options, projectInfo);
   } else {
-    logger53.info("Skipping component tests due to --skip-build option");
+    logger54.info("Skipping component tests due to --skip-build option");
   }
   const e2eResult = await runE2eTests(testPath, options, projectInfo);
   if (componentResult.failed || e2eResult.failed) {
     if (componentResult.failed) {
-      logger53.error("Component tests failed.");
+      logger54.error("Component tests failed.");
     }
     if (e2eResult.failed) {
-      logger53.error("E2E tests failed.");
+      logger54.error("E2E tests failed.");
     }
-    logger53.error("Test suite failed.");
+    logger54.error("Test suite failed.");
     process.exit(1);
   }
-  logger53.success("All tests passed successfully!");
+  logger54.success("All tests passed successfully!");
   process.exit(0);
 }
 // src/commands/test/utils/plugin-utils.ts
-import { logger as logger54 } from "@elizaos/core";
+import { logger as logger55 } from "@elizaos/core";
 
 // src/commands/test/index.ts
 var test = new Command().name("test").description("Run tests for the current project or a specified plugin").argument("[path]", "Optional path to the project or plugin to test").addOption(new Option("-t, --type <type>", "the type of test to run").choices(["component", "e2e", "all"]).default("all")).option("--port <port>", "The port to run e2e tests on", validatePort).option("--name <name>", "Filter tests by name").option("--skip-build", "Skip building before running tests").option("--skip-type-check", "Skip TypeScript validation before running tests").hook("preAction", async (thisCommand) => {
@@ -316711,31 +316904,31 @@ var test = new Command().name("test").description("Run tests for the current pro
   const projectInfo = getProjectType(testPath);
   await installPluginDependencies(projectInfo);
 }).action(async (testPath, options) => {
-  logger55.info("Starting tests...");
+  logger56.info("Starting tests...");
   try {
     const projectInfo = getProjectType(testPath);
     switch (options.type) {
       case "component":
-        logger55.info("Running component tests only...");
+        logger56.info("Running component tests only...");
         const componentResult = await runComponentTests(testPath, options, projectInfo);
         if (componentResult.failed) {
-          logger55.error("Component tests failed.");
+          logger56.error("Component tests failed.");
           process.exit(1);
         }
-        logger55.success("Component tests passed successfully!");
+        logger56.success("Component tests passed successfully!");
         break;
       case "e2e":
-        logger55.info("Running e2e tests only...");
+        logger56.info("Running e2e tests only...");
         const e2eResult = await runE2eTests(testPath, options, projectInfo);
         if (e2eResult.failed) {
-          logger55.error("E2E tests failed.");
+          logger56.error("E2E tests failed.");
           process.exit(1);
         }
-        logger55.success("E2E tests passed successfully!");
+        logger56.success("E2E tests passed successfully!");
         break;
       case "all":
       default:
-        logger55.info("Running all tests...");
+        logger56.info("Running all tests...");
         await runAllTests(testPath, options);
         break;
     }
@@ -316749,19 +316942,19 @@ var test = new Command().name("test").description("Run tests for the current pro
 init_utils();
 init_directory_detection();
 init_esm();
-import { logger as logger57 } from "@elizaos/core";
+import { logger as logger58 } from "@elizaos/core";
 
 // src/commands/update/actions/dependency-update.ts
 init_utils();
 init_dist2();
 import { promises as fs49 } from "fs";
-import * as path73 from "path";
+import * as path74 from "path";
 
 // src/commands/update/utils/package-utils.ts
 init_bun_exec();
 init_utils();
 import fs48 from "fs/promises";
-import { logger as logger56 } from "@elizaos/core";
+import { logger as logger57 } from "@elizaos/core";
 async function checkForUpdates(dependencies) {
   const updates = {};
   const elizaPackages = Object.entries(dependencies).filter(([pkg]) => pkg.startsWith(ELIZAOS_ORG)).filter(([, version3]) => !isWorkspaceVersion(version3));
@@ -316773,7 +316966,7 @@ async function checkForUpdates(dependencies) {
     if (needsUpdate) {
       updates[pkg] = { current: currentVersion, latest: latestVersion };
     } else if (error47) {
-      logger56.debug(`${pkg}: ${error47}`);
+      logger57.debug(`${pkg}: ${error47}`);
     }
   }
   return { hasUpdates: Object.keys(updates).length > 0, updates };
@@ -316822,7 +317015,7 @@ Installing updated packages...`);
 // src/commands/update/actions/dependency-update.ts
 async function updateDependencies(cwd, isPlugin2, options = {}) {
   const { dryRun = false, skipBuild = false } = options;
-  const packageJsonPath = path73.join(cwd, "package.json");
+  const packageJsonPath = path74.join(cwd, "package.json");
   const content = await fs49.readFile(packageJsonPath, "utf8");
   const packageJson = JSON.parse(content);
   const allDependencies = {
@@ -316896,7 +317089,7 @@ var update3 = new Command().name("update").description("Update ElizaOS CLI and p
   try {
     await displayBanner(true);
   } catch {
-    logger57.debug("Banner display failed, continuing with update");
+    logger58.debug("Banner display failed, continuing with update");
   }
 }).action(async (options) => {
   try {
@@ -316934,7 +317127,7 @@ var update3 = new Command().name("update").description("Update ElizaOS CLI and p
         console.info("To create a new ElizaOS project, use: elizaos create <project-name>");
         return;
       }
-      logger57.debug(`Detected ${directoryInfo.type}`);
+      logger58.debug(`Detected ${directoryInfo.type}`);
       if (!isInProject) {
         handleInvalidDirectory(directoryInfo);
         return;
@@ -316969,7 +317162,7 @@ init_utils();
 init_local_cli_delegation();
 init_esm();
 init_emoji_handler();
-import { logger as logger58 } from "@elizaos/core";
+import { logger as logger59 } from "@elizaos/core";
 
 // src/commands/scenario/index.ts
 init_esm();
@@ -316977,7 +317170,7 @@ init_js_yaml();
 init_schema();
 init_LocalEnvironmentProvider();
 import fs54 from "fs";
-import path76 from "path";
+import path77 from "path";
 import { logger as elizaLogger } from "@elizaos/core";
 
 // src/commands/scenario/src/E2BEnvironmentProvider.ts
@@ -317199,9 +317392,9 @@ class MockEngine {
     }
     if (mock.responseFn) {
       try {
-        const input2 = this.extractInputFromArgs(args);
+        const input3 = this.extractInputFromArgs(args);
         const context2 = this.buildRequestContext(args);
-        return this.parseResponseTemplate(mock.responseFn, { args, input: input2, context: context2 });
+        return this.parseResponseTemplate(mock.responseFn, { args, input: input3, context: context2 });
       } catch (error47) {
         this.logger.error(`Response template error: ${error47}`);
         throw error47;
@@ -317212,7 +317405,7 @@ class MockEngine {
   async matchesCondition(mock, args) {
     if (!mock.when)
       return true;
-    const input2 = this.extractInputFromArgs(args);
+    const input3 = this.extractInputFromArgs(args);
     const context2 = this.buildRequestContext(args);
     if (mock.when.args) {
       if (!import_lodash.default.isEqual(args, mock.when.args)) {
@@ -317220,7 +317413,7 @@ class MockEngine {
       }
     }
     if (mock.when.input) {
-      if (!this.matchesInput(input2, mock.when.input)) {
+      if (!this.matchesInput(input3, mock.when.input)) {
         return false;
       }
     }
@@ -317231,7 +317424,7 @@ class MockEngine {
     }
     if (mock.when.matcher) {
       try {
-        const result = this.evaluateTemplate(mock.when.matcher, { args, input: input2, context: context2 });
+        const result = this.evaluateTemplate(mock.when.matcher, { args, input: input3, context: context2 });
         if (!result) {
           return false;
         }
@@ -317248,16 +317441,16 @@ class MockEngine {
     return true;
   }
   extractInputFromArgs(args) {
-    const input2 = {};
+    const input3 = {};
     for (let i2 = 0;i2 < args.length; i2++) {
       const arg = args[i2];
       if (typeof arg === "object" && arg !== null) {
-        Object.assign(input2, arg);
+        Object.assign(input3, arg);
       } else if (typeof arg === "string" || typeof arg === "number") {
-        input2[`arg${i2}`] = arg;
+        input3[`arg${i2}`] = arg;
       }
     }
-    return input2;
+    return input3;
   }
   buildRequestContext(args) {
     return {
@@ -317289,9 +317482,9 @@ class MockEngine {
     }
     return score;
   }
-  matchesInput(input2, expectedInput) {
+  matchesInput(input3, expectedInput) {
     for (const [key, value] of Object.entries(expectedInput)) {
-      if (!import_lodash.default.isEqual(input2[key], value)) {
+      if (!import_lodash.default.isEqual(input3[key], value)) {
         return false;
       }
     }
@@ -317745,14 +317938,14 @@ class RunDataAggregator {
 // src/commands/scenario/index.ts
 var __dirname = "/home/runner/work/eliza/eliza/packages/cli/src/commands/scenario";
 async function runEvaluationsWithFallback(evaluationEngine, evaluations, result) {
-  const logger58 = elizaLogger || console;
+  const logger59 = elizaLogger || console;
   try {
-    logger58.debug("[Evaluation] Using enhanced evaluations with structured output");
+    logger59.debug("[Evaluation] Using enhanced evaluations with structured output");
     const enhancedResults = await evaluationEngine.runEnhancedEvaluations(evaluations, result);
     if (Array.isArray(enhancedResults) && enhancedResults.length > 0) {
       const firstResult = enhancedResults[0];
       if (firstResult && typeof firstResult.evaluator_type === "string" && typeof firstResult.success === "boolean" && typeof firstResult.summary === "string" && typeof firstResult.details === "object") {
-        logger58.debug(`[Evaluation] Enhanced evaluations successful - ${enhancedResults.length} structured results`);
+        logger59.debug(`[Evaluation] Enhanced evaluations successful - ${enhancedResults.length} structured results`);
         return enhancedResults.map((enhanced) => ({
           success: enhanced.success,
           message: enhanced.summary,
@@ -317760,16 +317953,16 @@ async function runEvaluationsWithFallback(evaluationEngine, evaluations, result)
         }));
       }
     }
-    logger58.warn("[Evaluation] Enhanced results invalid, falling back to legacy evaluations");
+    logger59.warn("[Evaluation] Enhanced results invalid, falling back to legacy evaluations");
   } catch (error47) {
-    logger58.warn(`[Evaluation] Enhanced evaluations failed (${error47 instanceof Error ? error47.message : String(error47)}), falling back to legacy evaluations`);
+    logger59.warn(`[Evaluation] Enhanced evaluations failed (${error47 instanceof Error ? error47.message : String(error47)}), falling back to legacy evaluations`);
   }
-  logger58.debug("[Evaluation] Using legacy evaluation system (fallback)");
+  logger59.debug("[Evaluation] Using legacy evaluation system (fallback)");
   return await evaluationEngine.runEvaluations(evaluations, result);
 }
 var scenario = new Command().name("scenario").description("Manage and execute ElizaOS scenarios").addCommand(new Command("run").argument("<filePath>", "Path to the .scenario.yaml file").option("-l, --live", "Run scenario in live mode, ignoring mocks", false).description("Execute a scenario from a YAML file").action(async (filePath, options) => {
-  const logger58 = elizaLogger || console;
-  logger58.info(`Starting scenario run with args: ${JSON.stringify({ filePath, ...options })}`);
+  const logger59 = elizaLogger || console;
+  logger59.info(`Starting scenario run with args: ${JSON.stringify({ filePath, ...options })}`);
   let provider = null;
   let runtime = null;
   let server2 = null;
@@ -317780,20 +317973,20 @@ var scenario = new Command().name("scenario").description("Manage and execute El
   let finalStatus = false;
   let reporter = null;
   const scenarioRunId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const logsDir = path76.join(__dirname, "_logs_");
+  const logsDir = path77.join(__dirname, "_logs_");
   let dataAggregator = null;
   try {
-    const fullPath = path76.resolve(filePath);
-    logger58.info(`Attempting to read scenario file from: ${fullPath}`);
+    const fullPath = path77.resolve(filePath);
+    logger59.info(`Attempting to read scenario file from: ${fullPath}`);
     if (!fs54.existsSync(fullPath)) {
-      logger58.error(`Error: File not found at '${fullPath}'`);
+      logger59.error(`Error: File not found at '${fullPath}'`);
       process.exit(1);
     }
     const fileContents = fs54.readFileSync(fullPath, "utf8");
     const rawScenario = load2(fileContents);
     const validationResult = ScenarioSchema.safeParse(rawScenario);
     if (!validationResult.success) {
-      logger58.error("Scenario file validation failed:");
+      logger59.error("Scenario file validation failed:");
       console.error(JSON.stringify(validationResult.error.format(), null, 2));
       process.exit(1);
     }
@@ -317802,25 +317995,25 @@ var scenario = new Command().name("scenario").description("Manage and execute El
       fs54.mkdirSync(logsDir, { recursive: true });
     }
     if (scenario2.plugins && scenario2.plugins.length > 0) {
-      logger58.info("Parsing and validating plugins...");
+      logger59.info("Parsing and validating plugins...");
       const pluginResult = await parseAndValidate(scenario2.plugins);
       if (!pluginResult.valid) {
-        logger58.error("Plugin validation failed:");
+        logger59.error("Plugin validation failed:");
         pluginResult.errors.forEach((error47) => {
-          logger58.error(`  - ${error47}`);
+          logger59.error(`  - ${error47}`);
         });
         process.exit(1);
       }
       if (pluginResult.warnings.length > 0) {
-        logger58.warn("Plugin warnings:");
+        logger59.warn("Plugin warnings:");
         pluginResult.warnings.forEach((warning2) => {
-          logger58.warn(`  - ${warning2}`);
+          logger59.warn(`  - ${warning2}`);
         });
       }
-      logger58.info(generateSummary(pluginResult));
+      logger59.info(generateSummary(pluginResult));
       scenario2.parsedPlugins = pluginResult.plugins;
     } else {
-      logger58.info("No plugins specified in scenario");
+      logger59.info("No plugins specified in scenario");
     }
     reporter = new Reporter;
     reporter.reportStart(scenario2);
@@ -317835,7 +318028,7 @@ var scenario = new Command().name("scenario").description("Manage and execute El
     }
     const scenarioPlugins = Array.isArray(scenario2.plugins) ? scenario2.plugins.filter((p2) => p2.enabled !== false).map((p2) => typeof p2 === "string" ? p2 : p2.name) : [];
     const finalPlugins = Array.from(new Set([...scenarioPlugins, ...defaultPlugins]));
-    logger58.info(`Using plugins: ${JSON.stringify(finalPlugins)}`);
+    logger59.info(`Using plugins: ${JSON.stringify(finalPlugins)}`);
     if (scenario2.environment.type === "e2b") {
       const created = await createScenarioServerAndAgent(null, 3000, finalPlugins);
       server2 = created.server;
@@ -317855,18 +318048,18 @@ var scenario = new Command().name("scenario").description("Manage and execute El
         serverPort = created.port;
       }
       provider = new LocalEnvironmentProvider(server2, agentId, runtime, serverPort);
-      logger58.info("Using local environment");
+      logger59.info("Using local environment");
     } else {
-      logger58.error(`Unsupported environment type: '${scenario2.environment.type}'`);
+      logger59.error(`Unsupported environment type: '${scenario2.environment.type}'`);
       process.exit(1);
     }
     if (runtime && scenario2.setup?.mocks && !options.live) {
-      logger58.info("Initializing MockEngine...");
+      logger59.info("Initializing MockEngine...");
       mockEngine = new MockEngine(runtime);
-      logger58.info("Applying mocks...");
+      logger59.info("Applying mocks...");
       mockEngine.applyMocks(scenario2.setup.mocks);
     }
-    logger58.info(`Setting up '${scenario2.environment.type}' environment...`);
+    logger59.info(`Setting up '${scenario2.environment.type}' environment...`);
     await provider.setup(scenario2);
     if (runtime) {
       const trajectoryReconstructor = new TrajectoryReconstructor(runtime);
@@ -317876,42 +318069,42 @@ var scenario = new Command().name("scenario").description("Manage and execute El
       const combinationId = `single-${scenarioRunId}`;
       const parameters = { "scenario.file": filePath };
       dataAggregator.startRun(runId2, combinationId, parameters);
-      logger58.info(`\uD83D\uDCCA [DataAggregator] Started tracking run: ${runId2}`);
+      logger59.info(`\uD83D\uDCCA [DataAggregator] Started tracking run: ${runId2}`);
     }
-    logger58.info("Executing run block...");
+    logger59.info("Executing run block...");
     const startTime = Date.now();
     const results = await provider.run(scenario2);
     const endTime = Date.now();
     results.forEach((result) => {
       reporter?.reportExecutionResult(result);
     });
-    logger58.info(`\uD83D\uDCC2 Using logs directory: ${logsDir}`);
+    logger59.info(`\uD83D\uDCC2 Using logs directory: ${logsDir}`);
     const runId = generateRunFilename(1);
-    logger58.info(`\uD83D\uDD0D DEBUG: About to write ${results.length} execution results to ${logsDir}`);
+    logger59.info(`\uD83D\uDD0D DEBUG: About to write ${results.length} execution results to ${logsDir}`);
     results.forEach((result, i2) => {
       const executionFilename = generateStepFilename(runId, i2, "execution");
-      const executionPath = path76.join(logsDir, executionFilename);
+      const executionPath = path77.join(logsDir, executionFilename);
       fs54.writeFileSync(executionPath, JSON.stringify(result, null, 2));
-      logger58.info(`\uD83D\uDCC4 Execution results written to: ${executionPath}`);
+      logger59.info(`\uD83D\uDCC4 Execution results written to: ${executionPath}`);
     });
     const allEvaluationResults = [];
     if (runtime) {
       const evaluationEngine = new EvaluationEngine(runtime);
-      logger58.info("Running evaluations with runtime...");
+      logger59.info("Running evaluations with runtime...");
       for (let i2 = 0;i2 < results.length; i2++) {
         const step = scenario2.run[i2];
         const result = results[i2];
         if (step.evaluations && step.evaluations.length > 0) {
           const evaluationResults = await runEvaluationsWithFallback(evaluationEngine, step.evaluations, result);
           const evaluationFilename = generateStepFilename(runId, i2, "evaluation");
-          const evaluationPath = path76.join(logsDir, evaluationFilename);
+          const evaluationPath = path77.join(logsDir, evaluationFilename);
           fs54.writeFileSync(evaluationPath, JSON.stringify(evaluationResults, null, 2));
-          logger58.info(`\uD83D\uDCCA Evaluation results written to: ${evaluationPath}`);
+          logger59.info(`\uD83D\uDCCA Evaluation results written to: ${evaluationPath}`);
           allEvaluationResults.push(...evaluationResults);
         }
       }
     } else {
-      logger58.info("Running basic evaluations without runtime...");
+      logger59.info("Running basic evaluations without runtime...");
       for (let i2 = 0;i2 < results.length; i2++) {
         const step = scenario2.run[i2];
         const result = results[i2];
@@ -317941,9 +318134,9 @@ var scenario = new Command().name("scenario").description("Manage and execute El
             allEvaluationResults.push(evaluationResult);
           }
           const evaluationFilename = generateStepFilename(runId, i2, "evaluation");
-          const evaluationPath = path76.join(logsDir, evaluationFilename);
+          const evaluationPath = path77.join(logsDir, evaluationFilename);
           fs54.writeFileSync(evaluationPath, JSON.stringify(stepEvaluationResults, null, 2));
-          logger58.info(`\uD83D\uDCCA Basic evaluation results written to: ${evaluationPath}`);
+          logger59.info(`\uD83D\uDCCA Basic evaluation results written to: ${evaluationPath}`);
         }
       }
     }
@@ -317996,15 +318189,15 @@ var scenario = new Command().name("scenario").description("Manage and execute El
         });
         const scenarioRunResult = await dataAggregator.buildResult(roomId, enhancedEvaluationResults, combinedExecutionResult);
         const centralizedFilename = `${runId}.json`;
-        const centralizedPath = path76.join(logsDir, centralizedFilename);
+        const centralizedPath = path77.join(logsDir, centralizedFilename);
         fs54.writeFileSync(centralizedPath, JSON.stringify(scenarioRunResult, null, 2));
-        logger58.info(`\uD83D\uDCCB [DataAggregator] Centralized result written to: ${centralizedPath}`);
+        logger59.info(`\uD83D\uDCCB [DataAggregator] Centralized result written to: ${centralizedPath}`);
       } catch (aggregatorError) {
-        logger58.error(`[DataAggregator] Failed to generate centralized result: ${aggregatorError}`);
+        logger59.error(`[DataAggregator] Failed to generate centralized result: ${aggregatorError}`);
       }
     }
   } catch (error47) {
-    logger58.error("An error occurred during scenario execution:", error47 instanceof Error ? error47.message : String(error47));
+    logger59.error("An error occurred during scenario execution:", error47 instanceof Error ? error47.message : String(error47));
     if (dataAggregator) {
       try {
         dataAggregator.recordError(error47 instanceof Error ? error47 : new Error(String(error47)));
@@ -318017,32 +318210,32 @@ var scenario = new Command().name("scenario").description("Manage and execute El
           files: {}
         });
         const errorFilename = `run-${failedResult.run_id}.json`;
-        const errorPath = path76.join(logsDir, errorFilename);
+        const errorPath = path77.join(logsDir, errorFilename);
         fs54.writeFileSync(errorPath, JSON.stringify(failedResult, null, 2));
-        logger58.info(`\uD83D\uDCA5 [DataAggregator] Error result written to: ${errorPath}`);
+        logger59.info(`\uD83D\uDCA5 [DataAggregator] Error result written to: ${errorPath}`);
       } catch (aggregatorError) {
-        logger58.error(`[DataAggregator] Failed to record error: ${aggregatorError}`);
+        logger59.error(`[DataAggregator] Failed to record error: ${aggregatorError}`);
       }
     }
     process.exit(1);
   } finally {
     if (mockEngine) {
-      logger58.info("Reverting mocks...");
+      logger59.info("Reverting mocks...");
       mockEngine.revertMocks();
     }
     if (provider) {
-      logger58.info("Tearing down environment...");
+      logger59.info("Tearing down environment...");
       await provider.teardown();
     }
     if (runtime) {
       try {
         const e2bService = runtime.getService("e2b");
         if (e2bService && typeof e2bService.stop === "function") {
-          logger58.info("Stopping E2B service...");
+          logger59.info("Stopping E2B service...");
           await e2bService.stop();
         }
         await runtime.close();
-        logger58.info("Runtime shutdown complete");
+        logger59.info("Runtime shutdown complete");
       } catch {}
     }
     if (server2 && createdServer) {
@@ -318065,38 +318258,38 @@ var scenario = new Command().name("scenario").description("Manage and execute El
     validateMatrixParameterPaths: validateMatrixParameterPaths2,
     combinationToOverrides: combinationToOverrides2
   } = await Promise.resolve().then(() => (init_parameter_override(), exports_parameter_override));
-  const logger58 = elizaLogger || console;
-  logger58.info(`\uD83E\uDDEA Starting matrix analysis with config: ${configPath}`);
+  const logger59 = elizaLogger || console;
+  logger59.info(`\uD83E\uDDEA Starting matrix analysis with config: ${configPath}`);
   if (options.verbose) {
-    logger58.info(`Options: ${JSON.stringify(options, null, 2)}`);
+    logger59.info(`Options: ${JSON.stringify(options, null, 2)}`);
   }
   const { processManager: processManager2 } = await Promise.resolve().then(() => (init_process_manager(), exports_process_manager));
   let isShuttingDown = false;
   const handleShutdown = async (signal) => {
     if (isShuttingDown) {
-      logger58.info(`\uD83D\uDD27 [Matrix] Already shutting down, ignoring ${signal}`);
+      logger59.info(`\uD83D\uDD27 [Matrix] Already shutting down, ignoring ${signal}`);
       return;
     }
     isShuttingDown = true;
-    logger58.info(`\uD83D\uDD27 [Matrix] Received ${signal}, initiating graceful shutdown...`);
+    logger59.info(`\uD83D\uDD27 [Matrix] Received ${signal}, initiating graceful shutdown...`);
     const summary = processManager2.getSummary();
     if (summary.total > 0) {
-      logger58.info(`\uD83D\uDD27 [Matrix] Cleaning up ${summary.total} tracked processes...`);
+      logger59.info(`\uD83D\uDD27 [Matrix] Cleaning up ${summary.total} tracked processes...`);
       await processManager2.terminateAllProcesses();
-      logger58.info(`\uD83D\uDD27 [Matrix] Process cleanup completed`);
+      logger59.info(`\uD83D\uDD27 [Matrix] Process cleanup completed`);
     }
-    logger58.info(`\uD83D\uDD27 [Matrix] Shutdown complete`);
+    logger59.info(`\uD83D\uDD27 [Matrix] Shutdown complete`);
     process.exit(0);
   };
   process.on("SIGINT", () => handleShutdown("SIGINT"));
   process.on("SIGTERM", () => handleShutdown("SIGTERM"));
   try {
-    const fullPath = path76.resolve(configPath);
-    const configDir = path76.dirname(fullPath);
-    logger58.info(`\uD83D\uDCC2 Loading matrix configuration from: ${fullPath}`);
+    const fullPath = path77.resolve(configPath);
+    const configDir = path77.dirname(fullPath);
+    logger59.info(`\uD83D\uDCC2 Loading matrix configuration from: ${fullPath}`);
     if (!fs54.existsSync(fullPath)) {
-      logger58.error(`\u274C Error: Matrix configuration file not found at '${fullPath}'`);
-      logger58.info("\uD83D\uDCA1 Make sure the file exists and the path is correct.");
+      logger59.error(`\u274C Error: Matrix configuration file not found at '${fullPath}'`);
+      logger59.info("\uD83D\uDCA1 Make sure the file exists and the path is correct.");
       process.exit(1);
     }
     const fileContents = fs54.readFileSync(fullPath, "utf8");
@@ -318104,175 +318297,175 @@ var scenario = new Command().name("scenario").description("Manage and execute El
     try {
       rawMatrixConfig = load2(fileContents);
     } catch (yamlError) {
-      logger58.error(`\u274C Error: Failed to parse YAML configuration file:`);
-      logger58.error(yamlError instanceof Error ? yamlError.message : String(yamlError));
-      logger58.info("\uD83D\uDCA1 Check that your YAML syntax is valid.");
+      logger59.error(`\u274C Error: Failed to parse YAML configuration file:`);
+      logger59.error(yamlError instanceof Error ? yamlError.message : String(yamlError));
+      logger59.info("\uD83D\uDCA1 Check that your YAML syntax is valid.");
       process.exit(1);
     }
-    if (rawMatrixConfig.base_scenario && !path76.isAbsolute(rawMatrixConfig.base_scenario)) {
-      rawMatrixConfig.base_scenario = path76.resolve(configDir, rawMatrixConfig.base_scenario);
+    if (rawMatrixConfig.base_scenario && !path77.isAbsolute(rawMatrixConfig.base_scenario)) {
+      rawMatrixConfig.base_scenario = path77.resolve(configDir, rawMatrixConfig.base_scenario);
     }
-    logger58.info("\uD83D\uDD0D Validating matrix configuration...");
+    logger59.info("\uD83D\uDD0D Validating matrix configuration...");
     const validationResult = validateMatrixConfig2(rawMatrixConfig);
     if (!validationResult.success) {
-      logger58.error("\u274C Matrix configuration validation failed:");
+      logger59.error("\u274C Matrix configuration validation failed:");
       const errors3 = validationResult.error.format();
-      const formatErrors = (obj, path77 = "") => {
+      const formatErrors = (obj, path78 = "") => {
         if (obj._errors && obj._errors.length > 0) {
           obj._errors.forEach((error47) => {
-            logger58.error(`   ${path77}: ${error47}`);
+            logger59.error(`   ${path78}: ${error47}`);
           });
         }
         Object.keys(obj).forEach((key) => {
           if (key !== "_errors" && typeof obj[key] === "object") {
-            const newPath = path77 ? `${path77}.${key}` : key;
+            const newPath = path78 ? `${path78}.${key}` : key;
             formatErrors(obj[key], newPath);
           }
         });
       };
       formatErrors(errors3);
-      logger58.info("\uD83D\uDCA1 Please fix the configuration errors and try again.");
-      logger58.info("\uD83D\uDCD6 See the matrix testing documentation for examples and guidance.");
+      logger59.info("\uD83D\uDCA1 Please fix the configuration errors and try again.");
+      logger59.info("\uD83D\uDCD6 See the matrix testing documentation for examples and guidance.");
       process.exit(1);
     }
     const matrixConfig = validationResult.data;
-    logger58.info("\u2705 Matrix configuration is valid!");
+    logger59.info("\u2705 Matrix configuration is valid!");
     const totalCombinations = calculateTotalCombinations2(matrixConfig);
     const totalRuns = calculateTotalRuns2(matrixConfig);
-    logger58.info(`
+    logger59.info(`
 \uD83D\uDCCA Matrix Analysis:`);
-    logger58.info(`   Name: ${matrixConfig.name}`);
+    logger59.info(`   Name: ${matrixConfig.name}`);
     if (matrixConfig.description) {
-      logger58.info(`   Description: ${matrixConfig.description}`);
-    }
-    logger58.info(`   Base Scenario: ${matrixConfig.base_scenario}`);
-    logger58.info(`   Runs per combination: ${matrixConfig.runs_per_combination}`);
-    logger58.info(`   Matrix axes: ${matrixConfig.matrix.length}`);
-    logger58.info(`   Total combinations: ${totalCombinations}`);
-    logger58.info(`   Total test runs: ${totalRuns}`);
-    logger58.info(`
+      logger59.info(`   Description: ${matrixConfig.description}`);
+    }
+    logger59.info(`   Base Scenario: ${matrixConfig.base_scenario}`);
+    logger59.info(`   Runs per combination: ${matrixConfig.runs_per_combination}`);
+    logger59.info(`   Matrix axes: ${matrixConfig.matrix.length}`);
+    logger59.info(`   Total combinations: ${totalCombinations}`);
+    logger59.info(`   Total test runs: ${totalRuns}`);
+    logger59.info(`
 \uD83C\uDFAF Matrix Structure:`);
     matrixConfig.matrix.forEach((axis, index) => {
-      logger58.info(`   Axis ${index + 1}: ${axis.parameter}`);
-      logger58.info(`     Values: [${axis.values.map((v2) => JSON.stringify(v2)).join(", ")}]`);
-      logger58.info(`     Count: ${axis.values.length}`);
+      logger59.info(`   Axis ${index + 1}: ${axis.parameter}`);
+      logger59.info(`     Values: [${axis.values.map((v2) => JSON.stringify(v2)).join(", ")}]`);
+      logger59.info(`     Count: ${axis.values.length}`);
     });
     const baseScenarioPath = matrixConfig.base_scenario;
     if (!fs54.existsSync(baseScenarioPath)) {
-      logger58.error(`
+      logger59.error(`
 \u274C Error: Base scenario file not found at '${baseScenarioPath}'`);
-      logger58.info("\uD83D\uDCA1 Make sure the base_scenario path in your matrix config is correct.");
+      logger59.info("\uD83D\uDCA1 Make sure the base_scenario path in your matrix config is correct.");
       process.exit(1);
     }
-    logger58.info(`\u2705 Base scenario file found: ${baseScenarioPath}`);
+    logger59.info(`\u2705 Base scenario file found: ${baseScenarioPath}`);
     let baseScenario;
     try {
       const baseScenarioContents = fs54.readFileSync(baseScenarioPath, "utf8");
       baseScenario = load2(baseScenarioContents);
       const baseValidationResult = ScenarioSchema.safeParse(baseScenario);
       if (!baseValidationResult.success) {
-        logger58.error(`
+        logger59.error(`
 \u274C Error: Base scenario file is invalid:`);
-        logger58.error(JSON.stringify(baseValidationResult.error.format(), null, 2));
+        logger59.error(JSON.stringify(baseValidationResult.error.format(), null, 2));
         process.exit(1);
       }
-      logger58.info(`\u2705 Base scenario is valid`);
+      logger59.info(`\u2705 Base scenario is valid`);
     } catch (yamlError) {
-      logger58.error(`
+      logger59.error(`
 \u274C Error: Failed to parse base scenario YAML file:`);
-      logger58.error(yamlError instanceof Error ? yamlError.message : String(yamlError));
+      logger59.error(yamlError instanceof Error ? yamlError.message : String(yamlError));
       process.exit(1);
     }
-    logger58.info(`\uD83D\uDD0D Validating matrix parameter paths...`);
+    logger59.info(`\uD83D\uDD0D Validating matrix parameter paths...`);
     const pathValidation = validateMatrixParameterPaths2(baseScenario, matrixConfig.matrix);
     if (!pathValidation.valid) {
-      logger58.error(`
+      logger59.error(`
 \u274C Error: Invalid parameter paths in matrix configuration:`);
       pathValidation.invalidPaths.forEach((invalidPath) => {
-        logger58.error(`   - ${invalidPath}`);
+        logger59.error(`   - ${invalidPath}`);
       });
-      logger58.info("\uD83D\uDCA1 Make sure all parameter paths exist in your base scenario.");
-      logger58.info("\uD83D\uDCD6 Check the matrix testing documentation for parameter path examples.");
+      logger59.info("\uD83D\uDCA1 Make sure all parameter paths exist in your base scenario.");
+      logger59.info("\uD83D\uDCD6 Check the matrix testing documentation for parameter path examples.");
       process.exit(1);
     }
-    logger58.info(`\u2705 All matrix parameter paths are valid`);
+    logger59.info(`\u2705 All matrix parameter paths are valid`);
     const combinations = generateMatrixCombinations2(matrixConfig);
     if (options.verbose || options.dryRun) {
-      logger58.info(`
+      logger59.info(`
 \uD83D\uDD00 Matrix Combinations:`);
       combinations.forEach((combo, index) => {
-        logger58.info(`   ${index + 1}. ${combo.id}: ${JSON.stringify(combo.parameters, null, 0)}`);
+        logger59.info(`   ${index + 1}. ${combo.id}: ${JSON.stringify(combo.parameters, null, 0)}`);
       });
       if (combinations.length > 0 && options.verbose) {
-        logger58.info(`
+        logger59.info(`
 \uD83D\uDEE0\uFE0F  Parameter Override Preview:`);
         try {
           const firstCombination = combinations[0];
           const overrides = combinationToOverrides2(firstCombination.parameters);
-          logger58.info(`   \uD83D\uDCCB Example: ${firstCombination.id}`);
-          logger58.info(`   \uD83D\uDCCA Metadata: ${firstCombination.metadata.combinationIndex + 1} of ${firstCombination.metadata.totalCombinations}`);
-          logger58.info(`   \uD83D\uDCDD Original scenario name: "${baseScenario.name}"`);
-          logger58.info(`   \uD83D\uDCDD Modified scenario ready for execution`);
-          logger58.info(`   \uD83D\uDCDD Parameters applied:`);
+          logger59.info(`   \uD83D\uDCCB Example: ${firstCombination.id}`);
+          logger59.info(`   \uD83D\uDCCA Metadata: ${firstCombination.metadata.combinationIndex + 1} of ${firstCombination.metadata.totalCombinations}`);
+          logger59.info(`   \uD83D\uDCDD Original scenario name: "${baseScenario.name}"`);
+          logger59.info(`   \uD83D\uDCDD Modified scenario ready for execution`);
+          logger59.info(`   \uD83D\uDCDD Parameters applied:`);
           overrides.forEach((override) => {
-            logger58.info(`   \uD83D\uDD27 ${override.path}: ${JSON.stringify(override.value)}`);
+            logger59.info(`   \uD83D\uDD27 ${override.path}: ${JSON.stringify(override.value)}`);
           });
-          logger58.info(`   \uD83D\uDCDD This combination will run ${matrixConfig.runs_per_combination} time(s)`);
+          logger59.info(`   \uD83D\uDCDD This combination will run ${matrixConfig.runs_per_combination} time(s)`);
         } catch (error47) {
-          logger58.warn(`   \u26A0\uFE0F  Could not generate override preview: ${error47 instanceof Error ? error47.message : String(error47)}`);
+          logger59.warn(`   \u26A0\uFE0F  Could not generate override preview: ${error47 instanceof Error ? error47.message : String(error47)}`);
         }
       }
     }
     let filteredCombinations = combinations;
     if (options.filter) {
-      logger58.info(`
+      logger59.info(`
 \uD83D\uDD0D Applying filter: ${options.filter}`);
       filteredCombinations = filterCombinations2(combinations, options.filter);
-      logger58.info(`   Filtered to ${filteredCombinations.length} combinations`);
+      logger59.info(`   Filtered to ${filteredCombinations.length} combinations`);
     }
     if (totalRuns > 50) {
-      logger58.info(`
+      logger59.info(`
 \u26A0\uFE0F  Warning: This matrix will execute ${totalRuns} total test runs.`);
-      logger58.info("   This may take a significant amount of time and resources.");
-      logger58.info("   Consider using --filter to reduce the scope or increasing --parallel for faster execution.");
+      logger59.info("   This may take a significant amount of time and resources.");
+      logger59.info("   Consider using --filter to reduce the scope or increasing --parallel for faster execution.");
     }
     if (options.dryRun) {
-      logger58.info(`
+      logger59.info(`
 \uD83D\uDD0D Dry Run Complete - Matrix Analysis Only`);
-      logger58.info("\u2728 Matrix configuration is valid and ready for execution.");
-      logger58.info("\uD83D\uDCDD To execute the matrix, run the same command without --dry-run");
+      logger59.info("\u2728 Matrix configuration is valid and ready for execution.");
+      logger59.info("\uD83D\uDCDD To execute the matrix, run the same command without --dry-run");
       if (!isShuttingDown) {
         const summary = processManager2.getSummary();
         if (summary.total > 0) {
-          logger58.info(`\uD83D\uDD27 [Matrix] Cleaning up ${summary.total} processes after dry-run...`);
+          logger59.info(`\uD83D\uDD27 [Matrix] Cleaning up ${summary.total} processes after dry-run...`);
           await processManager2.terminateAllProcesses();
         }
       }
       process.exit(0);
     } else {
       const executionStats = calculateExecutionStats2(filteredCombinations, matrixConfig.runs_per_combination);
-      logger58.info(`
+      logger59.info(`
 \uD83D\uDE80 Matrix Execution Plan:`);
-      logger58.info(`   Parallel execution: ${options.parallel} concurrent runs`);
-      logger58.info(`   Total combinations to execute: ${executionStats.totalCombinations}`);
-      logger58.info(`   Total runs: ${executionStats.totalRuns}`);
-      logger58.info(`   Estimated duration: ${formatDuration2(executionStats.estimatedDuration.realistic)} (realistic)`);
-      logger58.info(`   Duration range: ${formatDuration2(executionStats.estimatedDuration.optimistic)} - ${formatDuration2(executionStats.estimatedDuration.pessimistic)}`);
-      logger58.info(`
+      logger59.info(`   Parallel execution: ${options.parallel} concurrent runs`);
+      logger59.info(`   Total combinations to execute: ${executionStats.totalCombinations}`);
+      logger59.info(`   Total runs: ${executionStats.totalRuns}`);
+      logger59.info(`   Estimated duration: ${formatDuration2(executionStats.estimatedDuration.realistic)} (realistic)`);
+      logger59.info(`   Duration range: ${formatDuration2(executionStats.estimatedDuration.optimistic)} - ${formatDuration2(executionStats.estimatedDuration.pessimistic)}`);
+      logger59.info(`
 \u2705 Matrix Ready for Execution:`);
-      logger58.info("   \uD83C\uDFAF Matrix configuration: \u2705 Valid");
-      logger58.info("   \uD83C\uDFAF Parameter combinations: \u2705 Generated");
-      logger58.info("   \uD83C\uDFAF Execution context: \u2705 Prepared");
-      logger58.info("   \uD83C\uDFAF Base scenario: \u2705 Validated");
-      logger58.info("\uD83D\uDD27 [DEBUG] About to import matrix-orchestrator...");
+      logger59.info("   \uD83C\uDFAF Matrix configuration: \u2705 Valid");
+      logger59.info("   \uD83C\uDFAF Parameter combinations: \u2705 Generated");
+      logger59.info("   \uD83C\uDFAF Execution context: \u2705 Prepared");
+      logger59.info("   \uD83C\uDFAF Base scenario: \u2705 Validated");
+      logger59.info("\uD83D\uDD27 [DEBUG] About to import matrix-orchestrator...");
       const { executeMatrixRuns: executeMatrixRuns2 } = await Promise.resolve().then(() => (init_matrix_orchestrator(), exports_matrix_orchestrator));
-      logger58.info("\uD83D\uDD27 [DEBUG] Successfully imported matrix-orchestrator");
-      logger58.info(`
+      logger59.info("\uD83D\uDD27 [DEBUG] Successfully imported matrix-orchestrator");
+      logger59.info(`
 \uD83D\uDE80 Starting Matrix Execution...`);
-      const logsDir = path76.join(__dirname, "_logs_");
+      const logsDir = path77.join(__dirname, "_logs_");
       const matrixRunId = generateRunFilename(1);
-      const outputDir = path76.join(logsDir, matrixRunId.replace("run-", "matrix-"));
-      logger58.info("\uD83D\uDD27 [DEBUG] About to call executeMatrixRuns...");
+      const outputDir = path77.join(logsDir, matrixRunId.replace("run-", "matrix-"));
+      logger59.info("\uD83D\uDD27 [DEBUG] About to call executeMatrixRuns...");
       const results = await executeMatrixRuns2(matrixConfig, filteredCombinations, {
         outputDir,
         maxParallel: parseInt(options.parallel, 10),
@@ -318281,54 +318474,54 @@ var scenario = new Command().name("scenario").description("Manage and execute El
         verbose: options.verbose,
         onProgress: (message, eventType, _data) => {
           if (options.verbose || eventType === "MATRIX_STARTED" || eventType === "COMBINATION_COMPLETED" || eventType === "MATRIX_COMPLETED") {
-            logger58.info(`\uD83D\uDD04 ${message}`);
+            logger59.info(`\uD83D\uDD04 ${message}`);
           }
         },
         onCombinationComplete: (summary) => {
-          logger58.info(`\u2705 Combination ${summary.combinationId} completed: ${summary.successfulRuns}/${summary.totalRuns} successful (${(summary.successRate * 100).toFixed(1)}%)`);
+          logger59.info(`\u2705 Combination ${summary.combinationId} completed: ${summary.successfulRuns}/${summary.totalRuns} successful (${(summary.successRate * 100).toFixed(1)}%)`);
         },
         onResourceWarning: (alert) => {
-          logger58.warn(`\u26A0\uFE0F  Resource ${alert.resource} at ${alert.currentUsage.toFixed(1)}%: ${alert.message}`);
+          logger59.warn(`\u26A0\uFE0F  Resource ${alert.resource} at ${alert.currentUsage.toFixed(1)}%: ${alert.message}`);
           if (alert.recommendation) {
-            logger58.info(`\uD83D\uDCA1 Recommendation: ${alert.recommendation}`);
+            logger59.info(`\uD83D\uDCA1 Recommendation: ${alert.recommendation}`);
           }
         }
       });
-      logger58.info("\uD83D\uDD27 [DEBUG] executeMatrixRuns completed successfully");
+      logger59.info("\uD83D\uDD27 [DEBUG] executeMatrixRuns completed successfully");
       const successfulRuns = results.filter((r2) => r2.success).length;
       const failedRuns = results.length - successfulRuns;
       const successRate = results.length > 0 ? successfulRuns / results.length * 100 : 0;
-      logger58.info(`
+      logger59.info(`
 \uD83C\uDF89 Matrix Execution Complete!`);
-      logger58.info(`\uD83D\uDCCA Results Summary:`);
-      logger58.info(`   Total runs: ${results.length}`);
-      logger58.info(`   Successful: ${successfulRuns}`);
-      logger58.info(`   Failed: ${failedRuns}`);
-      logger58.info(`   Success rate: ${successRate.toFixed(1)}%`);
-      logger58.info(`\uD83D\uDCC1 Results saved to: ${outputDir}`);
+      logger59.info(`\uD83D\uDCCA Results Summary:`);
+      logger59.info(`   Total runs: ${results.length}`);
+      logger59.info(`   Successful: ${successfulRuns}`);
+      logger59.info(`   Failed: ${failedRuns}`);
+      logger59.info(`   Success rate: ${successRate.toFixed(1)}%`);
+      logger59.info(`\uD83D\uDCC1 Results saved to: ${outputDir}`);
       if (!isShuttingDown) {
         const summary = processManager2.getSummary();
         if (summary.total > 0) {
-          logger58.info(`\uD83D\uDD27 [Matrix] Cleaning up ${summary.total} processes after completion...`);
+          logger59.info(`\uD83D\uDD27 [Matrix] Cleaning up ${summary.total} processes after completion...`);
           await processManager2.terminateAllProcesses();
-          logger58.info(`\uD83D\uDD27 [Matrix] Process cleanup completed`);
+          logger59.info(`\uD83D\uDD27 [Matrix] Process cleanup completed`);
         }
       }
       process.exit(failedRuns === 0 ? 0 : 1);
     }
   } catch (error47) {
-    logger58.error("\u274C An error occurred during matrix analysis:", error47 instanceof Error ? error47.message : String(error47));
+    logger59.error("\u274C An error occurred during matrix analysis:", error47 instanceof Error ? error47.message : String(error47));
     if (options.verbose && error47 instanceof Error && error47.stack) {
-      logger58.error(`Stack trace: ${error47.stack}`);
+      logger59.error(`Stack trace: ${error47.stack}`);
     }
     if (!isShuttingDown) {
       const summary = processManager2.getSummary();
       if (summary.total > 0) {
-        logger58.info(`\uD83D\uDD27 [Matrix] Cleaning up ${summary.total} processes after error...`);
+        logger59.info(`\uD83D\uDD27 [Matrix] Cleaning up ${summary.total} processes after error...`);
         await processManager2.terminateAllProcesses();
       }
     }
-    logger58.info("\uD83D\uDCA1 Use --verbose for more detailed error information.");
+    logger59.info("\uD83D\uDCA1 Use --verbose for more detailed error information.");
     process.exit(1);
   }
 }));
@@ -318349,19 +318542,19 @@ var shutdownState = {
 };
 async function gracefulShutdown(signal) {
   if (!shutdownState.tryInitiateShutdown()) {
-    logger58.debug(`Ignoring ${signal} - shutdown already in progress`);
+    logger59.debug(`Ignoring ${signal} - shutdown already in progress`);
     return;
   }
-  logger58.info(`Received ${signal}, shutting down gracefully...`);
+  logger59.info(`Received ${signal}, shutting down gracefully...`);
   try {
     const serverWasStopped = await stopServer();
     if (serverWasStopped) {
-      logger58.info("Server stopped successfully");
+      logger59.info("Server stopped successfully");
     }
   } catch (error47) {
     const errorMessage = error47 instanceof Error ? error47.message : String(error47);
-    logger58.error(`Error stopping server: ${errorMessage}`);
-    logger58.debug({ error: error47 }, "Full error details:");
+    logger59.error(`Error stopping server: ${errorMessage}`);
+    logger59.debug({ error: error47 }, "Full error details:");
   }
   const exitCode = signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 0;
   process.exit(exitCode);
@@ -318395,9 +318588,9 @@ async function main() {
   await program2.parseAsync();
 }
 main().catch((error47) => {
-  logger58.error({ error: error47 }, "An error occurred:");
+  logger59.error({ error: error47 }, "An error occurred:");
   process.exit(1);
 });
 
-//# debugId=8B02166FCBF022B964756E2164756E21
+//# debugId=C897D0A55C8868B464756E2164756E21
 //# sourceMappingURL=index.js.map