agenter 0.0.1 → 0.0.3

package/dist/agenter.js

@@ -48,6 +48,1002 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __promiseAll = (args) => Promise.all(args);
 var __require = import.meta.require;
 
+// node_modules/.bun/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js
+var require_Reflect = __commonJS(() => {
+  /*! *****************************************************************************
+  Copyright (C) Microsoft. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
+  
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
+  
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
+  ***************************************************************************** */
+  var Reflect2;
+  (function(Reflect3) {
+    (function(factory) {
+      var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+      var exporter = makeExporter(Reflect3);
+      if (typeof root.Reflect !== "undefined") {
+        exporter = makeExporter(root.Reflect, exporter);
+      }
+      factory(exporter, root);
+      if (typeof root.Reflect === "undefined") {
+        root.Reflect = Reflect3;
+      }
+      function makeExporter(target, previous) {
+        return function(key, value) {
+          Object.defineProperty(target, key, { configurable: true, writable: true, value });
+          if (previous)
+            previous(key, value);
+        };
+      }
+      function functionThis() {
+        try {
+          return Function("return this;")();
+        } catch (_) {}
+      }
+      function indirectEvalThis() {
+        try {
+          return (undefined, eval)("(function() { return this; })()");
+        } catch (_) {}
+      }
+      function sloppyModeThis() {
+        return functionThis() || indirectEvalThis();
+      }
+    })(function(exporter, root) {
+      var hasOwn = Object.prototype.hasOwnProperty;
+      var supportsSymbol = typeof Symbol === "function";
+      var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+      var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+      var supportsCreate = typeof Object.create === "function";
+      var supportsProto = { __proto__: [] } instanceof Array;
+      var downLevel = !supportsCreate && !supportsProto;
+      var HashMap = {
+        create: supportsCreate ? function() {
+          return MakeDictionary(Object.create(null));
+        } : supportsProto ? function() {
+          return MakeDictionary({ __proto__: null });
+        } : function() {
+          return MakeDictionary({});
+        },
+        has: downLevel ? function(map, key) {
+          return hasOwn.call(map, key);
+        } : function(map, key) {
+          return key in map;
+        },
+        get: downLevel ? function(map, key) {
+          return hasOwn.call(map, key) ? map[key] : undefined;
+        } : function(map, key) {
+          return map[key];
+        }
+      };
+      var functionPrototype = Object.getPrototypeOf(Function);
+      var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+      var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+      var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+      var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : undefined;
+      var metadataRegistry = GetOrCreateMetadataRegistry();
+      var metadataProvider = CreateMetadataProvider(metadataRegistry);
+      function decorate(decorators, target, propertyKey, attributes) {
+        if (!IsUndefined(propertyKey)) {
+          if (!IsArray(decorators))
+            throw new TypeError;
+          if (!IsObject(target))
+            throw new TypeError;
+          if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
+            throw new TypeError;
+          if (IsNull(attributes))
+            attributes = undefined;
+          propertyKey = ToPropertyKey(propertyKey);
+          return DecorateProperty(decorators, target, propertyKey, attributes);
+        } else {
+          if (!IsArray(decorators))
+            throw new TypeError;
+          if (!IsConstructor(target))
+            throw new TypeError;
+          return DecorateConstructor(decorators, target);
+        }
+      }
+      exporter("decorate", decorate);
+      function metadata(metadataKey, metadataValue) {
+        function decorator(target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError;
+          if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
+            throw new TypeError;
+          OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+        }
+        return decorator;
+      }
+      exporter("metadata", metadata);
+      function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+      }
+      exporter("defineMetadata", defineMetadata);
+      function hasMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("hasMetadata", hasMetadata);
+      function hasOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("hasOwnMetadata", hasOwnMetadata);
+      function getMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("getMetadata", getMetadata);
+      function getOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("getOwnMetadata", getOwnMetadata);
+      function getMetadataKeys(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryMetadataKeys(target, propertyKey);
+      }
+      exporter("getMetadataKeys", getMetadataKeys);
+      function getOwnMetadataKeys(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryOwnMetadataKeys(target, propertyKey);
+      }
+      exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+      function deleteMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        var provider = GetMetadataProvider(target, propertyKey, false);
+        if (IsUndefined(provider))
+          return false;
+        return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("deleteMetadata", deleteMetadata);
+      function DecorateConstructor(decorators, target) {
+        for (var i = decorators.length - 1;i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target);
+          if (!IsUndefined(decorated) && !IsNull(decorated)) {
+            if (!IsConstructor(decorated))
+              throw new TypeError;
+            target = decorated;
+          }
+        }
+        return target;
+      }
+      function DecorateProperty(decorators, target, propertyKey, descriptor) {
+        for (var i = decorators.length - 1;i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target, propertyKey, descriptor);
+          if (!IsUndefined(decorated) && !IsNull(decorated)) {
+            if (!IsObject(decorated))
+              throw new TypeError;
+            descriptor = decorated;
+          }
+        }
+        return descriptor;
+      }
+      function OrdinaryHasMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return true;
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull(parent))
+          return OrdinaryHasMetadata(MetadataKey, parent, P);
+        return false;
+      }
+      function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (IsUndefined(provider))
+          return false;
+        return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+      }
+      function OrdinaryGetMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull(parent))
+          return OrdinaryGetMetadata(MetadataKey, parent, P);
+        return;
+      }
+      function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (IsUndefined(provider))
+          return;
+        return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+      }
+      function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+        var provider = GetMetadataProvider(O, P, true);
+        provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
+      }
+      function OrdinaryMetadataKeys(O, P) {
+        var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (parent === null)
+          return ownKeys;
+        var parentKeys = OrdinaryMetadataKeys(parent, P);
+        if (parentKeys.length <= 0)
+          return ownKeys;
+        if (ownKeys.length <= 0)
+          return parentKeys;
+        var set = new _Set;
+        var keys = [];
+        for (var _i = 0, ownKeys_1 = ownKeys;_i < ownKeys_1.length; _i++) {
+          var key = ownKeys_1[_i];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        for (var _a = 0, parentKeys_1 = parentKeys;_a < parentKeys_1.length; _a++) {
+          var key = parentKeys_1[_a];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        return keys;
+      }
+      function OrdinaryOwnMetadataKeys(O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (!provider) {
+          return [];
+        }
+        return provider.OrdinaryOwnMetadataKeys(O, P);
+      }
+      function Type(x) {
+        if (x === null)
+          return 1;
+        switch (typeof x) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return x === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function IsUndefined(x) {
+        return x === undefined;
+      }
+      function IsNull(x) {
+        return x === null;
+      }
+      function IsSymbol(x) {
+        return typeof x === "symbol";
+      }
+      function IsObject(x) {
+        return typeof x === "object" ? x !== null : typeof x === "function";
+      }
+      function ToPrimitive(input, PreferredType) {
+        switch (Type(input)) {
+          case 0:
+            return input;
+          case 1:
+            return input;
+          case 2:
+            return input;
+          case 3:
+            return input;
+          case 4:
+            return input;
+          case 5:
+            return input;
+        }
+        var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
+        var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+        if (exoticToPrim !== undefined) {
+          var result = exoticToPrim.call(input, hint);
+          if (IsObject(result))
+            throw new TypeError;
+          return result;
+        }
+        return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
+      }
+      function OrdinaryToPrimitive(O, hint) {
+        if (hint === "string") {
+          var toString_1 = O.toString;
+          if (IsCallable(toString_1)) {
+            var result = toString_1.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+          var valueOf = O.valueOf;
+          if (IsCallable(valueOf)) {
+            var result = valueOf.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+        } else {
+          var valueOf = O.valueOf;
+          if (IsCallable(valueOf)) {
+            var result = valueOf.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+          var toString_2 = O.toString;
+          if (IsCallable(toString_2)) {
+            var result = toString_2.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+        }
+        throw new TypeError;
+      }
+      function ToBoolean(argument) {
+        return !!argument;
+      }
+      function ToString(argument) {
+        return "" + argument;
+      }
+      function ToPropertyKey(argument) {
+        var key = ToPrimitive(argument, 3);
+        if (IsSymbol(key))
+          return key;
+        return ToString(key);
+      }
+      function IsArray(argument) {
+        return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+      }
+      function IsCallable(argument) {
+        return typeof argument === "function";
+      }
+      function IsConstructor(argument) {
+        return typeof argument === "function";
+      }
+      function IsPropertyKey(argument) {
+        switch (Type(argument)) {
+          case 3:
+            return true;
+          case 4:
+            return true;
+          default:
+            return false;
+        }
+      }
+      function SameValueZero(x, y) {
+        return x === y || x !== x && y !== y;
+      }
+      function GetMethod(V, P) {
+        var func = V[P];
+        if (func === undefined || func === null)
+          return;
+        if (!IsCallable(func))
+          throw new TypeError;
+        return func;
+      }
+      function GetIterator(obj) {
+        var method = GetMethod(obj, iteratorSymbol);
+        if (!IsCallable(method))
+          throw new TypeError;
+        var iterator = method.call(obj);
+        if (!IsObject(iterator))
+          throw new TypeError;
+        return iterator;
+      }
+      function IteratorValue(iterResult) {
+        return iterResult.value;
+      }
+      function IteratorStep(iterator) {
+        var result = iterator.next();
+        return result.done ? false : result;
+      }
+      function IteratorClose(iterator) {
+        var f = iterator["return"];
+        if (f)
+          f.call(iterator);
+      }
+      function OrdinaryGetPrototypeOf(O) {
+        var proto = Object.getPrototypeOf(O);
+        if (typeof O !== "function" || O === functionPrototype)
+          return proto;
+        if (proto !== functionPrototype)
+          return proto;
+        var prototype = O.prototype;
+        var prototypeProto = prototype && Object.getPrototypeOf(prototype);
+        if (prototypeProto == null || prototypeProto === Object.prototype)
+          return proto;
+        var constructor = prototypeProto.constructor;
+        if (typeof constructor !== "function")
+          return proto;
+        if (constructor === O)
+          return proto;
+        return constructor;
+      }
+      function CreateMetadataRegistry() {
+        var fallback;
+        if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
+          fallback = CreateFallbackProvider(root.Reflect);
+        }
+        var first;
+        var second;
+        var rest;
+        var targetProviderMap = new _WeakMap;
+        var registry = {
+          registerProvider,
+          getProvider,
+          setProvider
+        };
+        return registry;
+        function registerProvider(provider) {
+          if (!Object.isExtensible(registry)) {
+            throw new Error("Cannot add provider to a frozen registry.");
+          }
+          switch (true) {
+            case fallback === provider:
+              break;
+            case IsUndefined(first):
+              first = provider;
+              break;
+            case first === provider:
+              break;
+            case IsUndefined(second):
+              second = provider;
+              break;
+            case second === provider:
+              break;
+            default:
+              if (rest === undefined)
+                rest = new _Set;
+              rest.add(provider);
+              break;
+          }
+        }
+        function getProviderNoCache(O, P) {
+          if (!IsUndefined(first)) {
+            if (first.isProviderFor(O, P))
+              return first;
+            if (!IsUndefined(second)) {
+              if (second.isProviderFor(O, P))
+                return first;
+              if (!IsUndefined(rest)) {
+                var iterator = GetIterator(rest);
+                while (true) {
+                  var next = IteratorStep(iterator);
+                  if (!next) {
+                    return;
+                  }
+                  var provider = IteratorValue(next);
+                  if (provider.isProviderFor(O, P)) {
+                    IteratorClose(iterator);
+                    return provider;
+                  }
+                }
+              }
+            }
+          }
+          if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
+            return fallback;
+          }
+          return;
+        }
+        function getProvider(O, P) {
+          var providerMap = targetProviderMap.get(O);
+          var provider;
+          if (!IsUndefined(providerMap)) {
+            provider = providerMap.get(P);
+          }
+          if (!IsUndefined(provider)) {
+            return provider;
+          }
+          provider = getProviderNoCache(O, P);
+          if (!IsUndefined(provider)) {
+            if (IsUndefined(providerMap)) {
+              providerMap = new _Map;
+              targetProviderMap.set(O, providerMap);
+            }
+            providerMap.set(P, provider);
+          }
+          return provider;
+        }
+        function hasProvider(provider) {
+          if (IsUndefined(provider))
+            throw new TypeError;
+          return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
+        }
+        function setProvider(O, P, provider) {
+          if (!hasProvider(provider)) {
+            throw new Error("Metadata provider not registered.");
+          }
+          var existingProvider = getProvider(O, P);
+          if (existingProvider !== provider) {
+            if (!IsUndefined(existingProvider)) {
+              return false;
+            }
+            var providerMap = targetProviderMap.get(O);
+            if (IsUndefined(providerMap)) {
+              providerMap = new _Map;
+              targetProviderMap.set(O, providerMap);
+            }
+            providerMap.set(P, provider);
+          }
+          return true;
+        }
+      }
+      function GetOrCreateMetadataRegistry() {
+        var metadataRegistry2;
+        if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+          metadataRegistry2 = root.Reflect[registrySymbol];
+        }
+        if (IsUndefined(metadataRegistry2)) {
+          metadataRegistry2 = CreateMetadataRegistry();
+        }
+        if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+          Object.defineProperty(root.Reflect, registrySymbol, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: metadataRegistry2
+          });
+        }
+        return metadataRegistry2;
+      }
+      function CreateMetadataProvider(registry) {
+        var metadata2 = new _WeakMap;
+        var provider = {
+          isProviderFor: function(O, P) {
+            var targetMetadata = metadata2.get(O);
+            if (IsUndefined(targetMetadata))
+              return false;
+            return targetMetadata.has(P);
+          },
+          OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
+          OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
+          OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
+          OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
+          OrdinaryDeleteMetadata
+        };
+        metadataRegistry.registerProvider(provider);
+        return provider;
+        function GetOrCreateMetadataMap(O, P, Create) {
+          var targetMetadata = metadata2.get(O);
+          var createdTargetMetadata = false;
+          if (IsUndefined(targetMetadata)) {
+            if (!Create)
+              return;
+            targetMetadata = new _Map;
+            metadata2.set(O, targetMetadata);
+            createdTargetMetadata = true;
+          }
+          var metadataMap = targetMetadata.get(P);
+          if (IsUndefined(metadataMap)) {
+            if (!Create)
+              return;
+            metadataMap = new _Map;
+            targetMetadata.set(P, metadataMap);
+            if (!registry.setProvider(O, P, provider)) {
+              targetMetadata.delete(P);
+              if (createdTargetMetadata) {
+                metadata2.delete(O);
+              }
+              throw new Error("Wrong provider for target.");
+            }
+          }
+          return metadataMap;
+        }
+        function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return false;
+          return ToBoolean(metadataMap.has(MetadataKey));
+        }
+        function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return;
+          return metadataMap.get(MetadataKey);
+        }
+        function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, true);
+          metadataMap.set(MetadataKey, MetadataValue);
+        }
+        function OrdinaryOwnMetadataKeys2(O, P) {
+          var keys = [];
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return keys;
+          var keysObj = metadataMap.keys();
+          var iterator = GetIterator(keysObj);
+          var k = 0;
+          while (true) {
+            var next = IteratorStep(iterator);
+            if (!next) {
+              keys.length = k;
+              return keys;
+            }
+            var nextValue = IteratorValue(next);
+            try {
+              keys[k] = nextValue;
+            } catch (e) {
+              try {
+                IteratorClose(iterator);
+              } finally {
+                throw e;
+              }
+            }
+            k++;
+          }
+        }
+        function OrdinaryDeleteMetadata(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return false;
+          if (!metadataMap.delete(MetadataKey))
+            return false;
+          if (metadataMap.size === 0) {
+            var targetMetadata = metadata2.get(O);
+            if (!IsUndefined(targetMetadata)) {
+              targetMetadata.delete(P);
+              if (targetMetadata.size === 0) {
+                metadata2.delete(targetMetadata);
+              }
+            }
+          }
+          return true;
+        }
+      }
+      function CreateFallbackProvider(reflect) {
+        var { defineMetadata: defineMetadata2, hasOwnMetadata: hasOwnMetadata2, getOwnMetadata: getOwnMetadata2, getOwnMetadataKeys: getOwnMetadataKeys2, deleteMetadata: deleteMetadata2 } = reflect;
+        var metadataOwner = new _WeakMap;
+        var provider = {
+          isProviderFor: function(O, P) {
+            var metadataPropertySet = metadataOwner.get(O);
+            if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
+              return true;
+            }
+            if (getOwnMetadataKeys2(O, P).length) {
+              if (IsUndefined(metadataPropertySet)) {
+                metadataPropertySet = new _Set;
+                metadataOwner.set(O, metadataPropertySet);
+              }
+              metadataPropertySet.add(P);
+              return true;
+            }
+            return false;
+          },
+          OrdinaryDefineOwnMetadata: defineMetadata2,
+          OrdinaryHasOwnMetadata: hasOwnMetadata2,
+          OrdinaryGetOwnMetadata: getOwnMetadata2,
+          OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
+          OrdinaryDeleteMetadata: deleteMetadata2
+        };
+        return provider;
+      }
+      function GetMetadataProvider(O, P, Create) {
+        var registeredProvider = metadataRegistry.getProvider(O, P);
+        if (!IsUndefined(registeredProvider)) {
+          return registeredProvider;
+        }
+        if (Create) {
+          if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+            return metadataProvider;
+          }
+          throw new Error("Illegal state.");
+        }
+        return;
+      }
+      function CreateMapPolyfill() {
+        var cacheSentinel = {};
+        var arraySentinel = [];
+        var MapIterator = function() {
+          function MapIterator2(keys, values, selector) {
+            this._index = 0;
+            this._keys = keys;
+            this._values = values;
+            this._selector = selector;
+          }
+          MapIterator2.prototype["@@iterator"] = function() {
+            return this;
+          };
+          MapIterator2.prototype[iteratorSymbol] = function() {
+            return this;
+          };
+          MapIterator2.prototype.next = function() {
+            var index = this._index;
+            if (index >= 0 && index < this._keys.length) {
+              var result = this._selector(this._keys[index], this._values[index]);
+              if (index + 1 >= this._keys.length) {
+                this._index = -1;
+                this._keys = arraySentinel;
+                this._values = arraySentinel;
+              } else {
+                this._index++;
+              }
+              return { value: result, done: false };
+            }
+            return { value: undefined, done: true };
+          };
+          MapIterator2.prototype.throw = function(error) {
+            if (this._index >= 0) {
+              this._index = -1;
+              this._keys = arraySentinel;
+              this._values = arraySentinel;
+            }
+            throw error;
+          };
+          MapIterator2.prototype.return = function(value) {
+            if (this._index >= 0) {
+              this._index = -1;
+              this._keys = arraySentinel;
+              this._values = arraySentinel;
+            }
+            return { value, done: true };
+          };
+          return MapIterator2;
+        }();
+        var Map2 = function() {
+          function Map3() {
+            this._keys = [];
+            this._values = [];
+            this._cacheKey = cacheSentinel;
+            this._cacheIndex = -2;
+          }
+          Object.defineProperty(Map3.prototype, "size", {
+            get: function() {
+              return this._keys.length;
+            },
+            enumerable: true,
+            configurable: true
+          });
+          Map3.prototype.has = function(key) {
+            return this._find(key, false) >= 0;
+          };
+          Map3.prototype.get = function(key) {
+            var index = this._find(key, false);
+            return index >= 0 ? this._values[index] : undefined;
+          };
+          Map3.prototype.set = function(key, value) {
+            var index = this._find(key, true);
+            this._values[index] = value;
+            return this;
+          };
+          Map3.prototype.delete = function(key) {
+            var index = this._find(key, false);
+            if (index >= 0) {
+              var size = this._keys.length;
+              for (var i = index + 1;i < size; i++) {
+                this._keys[i - 1] = this._keys[i];
+                this._values[i - 1] = this._values[i];
+              }
+              this._keys.length--;
+              this._values.length--;
+              if (SameValueZero(key, this._cacheKey)) {
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              }
+              return true;
+            }
+            return false;
+          };
+          Map3.prototype.clear = function() {
+            this._keys.length = 0;
+            this._values.length = 0;
+            this._cacheKey = cacheSentinel;
+            this._cacheIndex = -2;
+          };
+          Map3.prototype.keys = function() {
+            return new MapIterator(this._keys, this._values, getKey);
+          };
+          Map3.prototype.values = function() {
+            return new MapIterator(this._keys, this._values, getValue);
+          };
+          Map3.prototype.entries = function() {
+            return new MapIterator(this._keys, this._values, getEntry);
+          };
+          Map3.prototype["@@iterator"] = function() {
+            return this.entries();
+          };
+          Map3.prototype[iteratorSymbol] = function() {
+            return this.entries();
+          };
+          Map3.prototype._find = function(key, insert) {
+            if (!SameValueZero(this._cacheKey, key)) {
+              this._cacheIndex = -1;
+              for (var i = 0;i < this._keys.length; i++) {
+                if (SameValueZero(this._keys[i], key)) {
+                  this._cacheIndex = i;
+                  break;
+                }
+              }
+            }
+            if (this._cacheIndex < 0 && insert) {
+              this._cacheIndex = this._keys.length;
+              this._keys.push(key);
+              this._values.push(undefined);
+            }
+            return this._cacheIndex;
+          };
+          return Map3;
+        }();
+        return Map2;
+        function getKey(key, _) {
+          return key;
+        }
+        function getValue(_, value) {
+          return value;
+        }
+        function getEntry(key, value) {
+          return [key, value];
+        }
+      }
+      function CreateSetPolyfill() {
+        var Set2 = function() {
+          function Set3() {
+            this._map = new _Map;
+          }
+          Object.defineProperty(Set3.prototype, "size", {
+            get: function() {
+              return this._map.size;
+            },
+            enumerable: true,
+            configurable: true
+          });
+          Set3.prototype.has = function(value) {
+            return this._map.has(value);
+          };
+          Set3.prototype.add = function(value) {
+            return this._map.set(value, value), this;
+          };
+          Set3.prototype.delete = function(value) {
+            return this._map.delete(value);
+          };
+          Set3.prototype.clear = function() {
+            this._map.clear();
+          };
+          Set3.prototype.keys = function() {
+            return this._map.keys();
+          };
+          Set3.prototype.values = function() {
+            return this._map.keys();
+          };
+          Set3.prototype.entries = function() {
+            return this._map.entries();
+          };
+          Set3.prototype["@@iterator"] = function() {
+            return this.keys();
+          };
+          Set3.prototype[iteratorSymbol] = function() {
+            return this.keys();
+          };
+          return Set3;
+        }();
+        return Set2;
+      }
+      function CreateWeakMapPolyfill() {
+        var UUID_SIZE = 16;
+        var keys = HashMap.create();
+        var rootKey = CreateUniqueKey();
+        return function() {
+          function WeakMap2() {
+            this._key = CreateUniqueKey();
+          }
+          WeakMap2.prototype.has = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? HashMap.has(table, this._key) : false;
+          };
+          WeakMap2.prototype.get = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? HashMap.get(table, this._key) : undefined;
+          };
+          WeakMap2.prototype.set = function(target, value) {
+            var table = GetOrCreateWeakMapTable(target, true);
+            table[this._key] = value;
+            return this;
+          };
+          WeakMap2.prototype.delete = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? delete table[this._key] : false;
+          };
+          WeakMap2.prototype.clear = function() {
+            this._key = CreateUniqueKey();
+          };
+          return WeakMap2;
+        }();
+        function CreateUniqueKey() {
+          var key;
+          do
+            key = "@@WeakMap@@" + CreateUUID();
+          while (HashMap.has(keys, key));
+          keys[key] = true;
+          return key;
+        }
+        function GetOrCreateWeakMapTable(target, create) {
+          if (!hasOwn.call(target, rootKey)) {
+            if (!create)
+              return;
+            Object.defineProperty(target, rootKey, { value: HashMap.create() });
+          }
+          return target[rootKey];
+        }
+        function FillRandomBytes(buffer, size) {
+          for (var i = 0;i < size; ++i)
+            buffer[i] = Math.random() * 255 | 0;
+          return buffer;
+        }
+        function GenRandomBytes(size) {
+          if (typeof Uint8Array === "function") {
+            var array = new Uint8Array(size);
+            if (typeof crypto !== "undefined") {
+              crypto.getRandomValues(array);
+            } else if (typeof msCrypto !== "undefined") {
+              msCrypto.getRandomValues(array);
+            } else {
+              FillRandomBytes(array, size);
+            }
+            return array;
+          }
+          return FillRandomBytes(new Array(size), size);
+        }
+        function CreateUUID() {
+          var data = GenRandomBytes(UUID_SIZE);
+          data[6] = data[6] & 79 | 64;
+          data[8] = data[8] & 191 | 128;
+          var result = "";
+          for (var offset = 0;offset < UUID_SIZE; ++offset) {
+            var byte = data[offset];
+            if (offset === 4 || offset === 6 || offset === 8)
+              result += "-";
+            if (byte < 16)
+              result += "0";
+            result += byte.toString(16).toLowerCase();
+          }
+          return result;
+        }
+      }
+      function MakeDictionary(obj) {
+        obj.__ = undefined;
+        delete obj.__;
+        return obj;
+      }
+    });
+  })(Reflect2 || (Reflect2 = {}));
+});
+
 // node_modules/.bun/zod@4.4.3/node_modules/zod/v4/core/core.js
 function $constructor(name, initializer, params) {
   function init(inst, def) {
@@ -14708,6 +15704,7 @@ var init_descriptor = __esm(() => {
   productCommandDescriptorSchema = exports_external.object({
     productId: productIdSchema,
     command: productCommandSchema,
+    description: exports_external.string().trim().min(1).optional(),
     packageName: productPackageNameSchema,
     bin: productBinDescriptorSchema,
     sourcePolicy: productSourcePolicySchema,
@@ -14882,7 +15879,11 @@ var DAEMON_RUNTIME_DESCRIPTOR_FILENAME = "daemon.runtime.json", isRecord = (valu
     homeDir: value.homeDir,
     updatedAt: value.updatedAt
   };
-}, resolveDaemonRuntimeDescriptorPath = (homeDir) => join2(resolve6(homeDir), ".agenter", DAEMON_RUNTIME_DESCRIPTOR_FILENAME), readDaemonRuntimeDescriptor = (homeDir) => {
+}, resolveDaemonRuntimeDescriptorPath = (homeDir) => join2(resolve6(homeDir), ".agenter", DAEMON_RUNTIME_DESCRIPTOR_FILENAME), resolveDaemonLogDir = (homeDir) => join2(resolve6(homeDir), ".agenter", "logs", "daemon"), resolveDaemonLogPath = (homeDir, authority, startedAt = new Date) => {
+  const safeHost = authority.host.replace(/[^a-zA-Z0-9_.-]/gu, "_");
+  const safeStartedAt = startedAt.toISOString().replace(/[:.]/gu, "-");
+  return join2(resolveDaemonLogDir(homeDir), `${safeStartedAt}-${safeHost}-${authority.port}.log`);
+}, readDaemonRuntimeDescriptor = (homeDir) => {
   const filePath = resolveDaemonRuntimeDescriptorPath(homeDir);
   try {
     return normalizeDaemonRuntimeDescriptor(JSON.parse(readFileSync4(filePath, "utf8")));
@@ -119938,1002 +120939,6 @@ var init_getCertificateInfo = __esm(() => {
   };
 });
 
-// node_modules/.bun/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js
-var require_Reflect = __commonJS(() => {
-  /*! *****************************************************************************
-  Copyright (C) Microsoft. All rights reserved.
-  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-  this file except in compliance with the License. You may obtain a copy of the
-  License at http://www.apache.org/licenses/LICENSE-2.0
-  
-  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-  MERCHANTABLITY OR NON-INFRINGEMENT.
-  
-  See the Apache Version 2.0 License for specific language governing permissions
-  and limitations under the License.
-  ***************************************************************************** */
-  var Reflect2;
-  (function(Reflect3) {
-    (function(factory) {
-      var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
-      var exporter = makeExporter(Reflect3);
-      if (typeof root.Reflect !== "undefined") {
-        exporter = makeExporter(root.Reflect, exporter);
-      }
-      factory(exporter, root);
-      if (typeof root.Reflect === "undefined") {
-        root.Reflect = Reflect3;
-      }
-      function makeExporter(target, previous) {
-        return function(key, value) {
-          Object.defineProperty(target, key, { configurable: true, writable: true, value });
-          if (previous)
-            previous(key, value);
-        };
-      }
-      function functionThis() {
-        try {
-          return Function("return this;")();
-        } catch (_) {}
-      }
-      function indirectEvalThis() {
-        try {
-          return (undefined, eval)("(function() { return this; })()");
-        } catch (_) {}
-      }
-      function sloppyModeThis() {
-        return functionThis() || indirectEvalThis();
-      }
-    })(function(exporter, root) {
-      var hasOwn4 = Object.prototype.hasOwnProperty;
-      var supportsSymbol = typeof Symbol === "function";
-      var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
-      var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
-      var supportsCreate = typeof Object.create === "function";
-      var supportsProto = { __proto__: [] } instanceof Array;
-      var downLevel = !supportsCreate && !supportsProto;
-      var HashMap = {
-        create: supportsCreate ? function() {
-          return MakeDictionary(Object.create(null));
-        } : supportsProto ? function() {
-          return MakeDictionary({ __proto__: null });
-        } : function() {
-          return MakeDictionary({});
-        },
-        has: downLevel ? function(map2, key) {
-          return hasOwn4.call(map2, key);
-        } : function(map2, key) {
-          return key in map2;
-        },
-        get: downLevel ? function(map2, key) {
-          return hasOwn4.call(map2, key) ? map2[key] : undefined;
-        } : function(map2, key) {
-          return map2[key];
-        }
-      };
-      var functionPrototype = Object.getPrototypeOf(Function);
-      var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
-      var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
-      var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
-      var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : undefined;
-      var metadataRegistry = GetOrCreateMetadataRegistry();
-      var metadataProvider = CreateMetadataProvider(metadataRegistry);
-      function decorate(decorators, target, propertyKey, attributes) {
-        if (!IsUndefined(propertyKey)) {
-          if (!IsArray(decorators))
-            throw new TypeError;
-          if (!IsObject(target))
-            throw new TypeError;
-          if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
-            throw new TypeError;
-          if (IsNull(attributes))
-            attributes = undefined;
-          propertyKey = ToPropertyKey(propertyKey);
-          return DecorateProperty(decorators, target, propertyKey, attributes);
-        } else {
-          if (!IsArray(decorators))
-            throw new TypeError;
-          if (!IsConstructor(target))
-            throw new TypeError;
-          return DecorateConstructor(decorators, target);
-        }
-      }
-      exporter("decorate", decorate);
-      function metadata(metadataKey, metadataValue) {
-        function decorator(target, propertyKey) {
-          if (!IsObject(target))
-            throw new TypeError;
-          if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
-            throw new TypeError;
-          OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
-        }
-        return decorator;
-      }
-      exporter("metadata", metadata);
-      function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
-        if (!IsObject(target))
-          throw new TypeError;
-        if (!IsUndefined(propertyKey))
-          propertyKey = ToPropertyKey(propertyKey);
-        return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
-      }
-      exporter("defineMetadata", defineMetadata);
-      function hasMetadata(metadataKey, target, propertyKey) {
-        if (!IsObject(target))
-          throw new TypeError;
-        if (!IsUndefined(propertyKey))
-          propertyKey = ToPropertyKey(propertyKey);
-        return OrdinaryHasMetadata(metadataKey, target, propertyKey);
-      }
-      exporter("hasMetadata", hasMetadata);
-      function hasOwnMetadata(metadataKey, target, propertyKey) {
-        if (!IsObject(target))
-          throw new TypeError;
-        if (!IsUndefined(propertyKey))
-          propertyKey = ToPropertyKey(propertyKey);
-        return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
-      }
-      exporter("hasOwnMetadata", hasOwnMetadata);
-      function getMetadata(metadataKey, target, propertyKey) {
-        if (!IsObject(target))
-          throw new TypeError;
-        if (!IsUndefined(propertyKey))
-          propertyKey = ToPropertyKey(propertyKey);
-        return OrdinaryGetMetadata(metadataKey, target, propertyKey);
-      }
-      exporter("getMetadata", getMetadata);
-      function getOwnMetadata(metadataKey, target, propertyKey) {
-        if (!IsObject(target))
-          throw new TypeError;
-        if (!IsUndefined(propertyKey))
-          propertyKey = ToPropertyKey(propertyKey);
-        return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
-      }
-      exporter("getOwnMetadata", getOwnMetadata);
-      function getMetadataKeys(target, propertyKey) {
-        if (!IsObject(target))
-          throw new TypeError;
-        if (!IsUndefined(propertyKey))
-          propertyKey = ToPropertyKey(propertyKey);
-        return OrdinaryMetadataKeys(target, propertyKey);
-      }
-      exporter("getMetadataKeys", getMetadataKeys);
-      function getOwnMetadataKeys(target, propertyKey) {
-        if (!IsObject(target))
-          throw new TypeError;
-        if (!IsUndefined(propertyKey))
-          propertyKey = ToPropertyKey(propertyKey);
-        return OrdinaryOwnMetadataKeys(target, propertyKey);
-      }
-      exporter("getOwnMetadataKeys", getOwnMetadataKeys);
-      function deleteMetadata(metadataKey, target, propertyKey) {
-        if (!IsObject(target))
-          throw new TypeError;
-        if (!IsUndefined(propertyKey))
-          propertyKey = ToPropertyKey(propertyKey);
-        if (!IsObject(target))
-          throw new TypeError;
-        if (!IsUndefined(propertyKey))
-          propertyKey = ToPropertyKey(propertyKey);
-        var provider = GetMetadataProvider(target, propertyKey, false);
-        if (IsUndefined(provider))
-          return false;
-        return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
-      }
-      exporter("deleteMetadata", deleteMetadata);
-      function DecorateConstructor(decorators, target) {
-        for (var i = decorators.length - 1;i >= 0; --i) {
-          var decorator = decorators[i];
-          var decorated = decorator(target);
-          if (!IsUndefined(decorated) && !IsNull(decorated)) {
-            if (!IsConstructor(decorated))
-              throw new TypeError;
-            target = decorated;
-          }
-        }
-        return target;
-      }
-      function DecorateProperty(decorators, target, propertyKey, descriptor) {
-        for (var i = decorators.length - 1;i >= 0; --i) {
-          var decorator = decorators[i];
-          var decorated = decorator(target, propertyKey, descriptor);
-          if (!IsUndefined(decorated) && !IsNull(decorated)) {
-            if (!IsObject(decorated))
-              throw new TypeError;
-            descriptor = decorated;
-          }
-        }
-        return descriptor;
-      }
-      function OrdinaryHasMetadata(MetadataKey, O, P) {
-        var hasOwn5 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
-        if (hasOwn5)
-          return true;
-        var parent = OrdinaryGetPrototypeOf(O);
-        if (!IsNull(parent))
-          return OrdinaryHasMetadata(MetadataKey, parent, P);
-        return false;
-      }
-      function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
-        var provider = GetMetadataProvider(O, P, false);
-        if (IsUndefined(provider))
-          return false;
-        return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
-      }
-      function OrdinaryGetMetadata(MetadataKey, O, P) {
-        var hasOwn5 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
-        if (hasOwn5)
-          return OrdinaryGetOwnMetadata(MetadataKey, O, P);
-        var parent = OrdinaryGetPrototypeOf(O);
-        if (!IsNull(parent))
-          return OrdinaryGetMetadata(MetadataKey, parent, P);
-        return;
-      }
-      function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
-        var provider = GetMetadataProvider(O, P, false);
-        if (IsUndefined(provider))
-          return;
-        return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
-      }
-      function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
-        var provider = GetMetadataProvider(O, P, true);
-        provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
-      }
-      function OrdinaryMetadataKeys(O, P) {
-        var ownKeys = OrdinaryOwnMetadataKeys(O, P);
-        var parent = OrdinaryGetPrototypeOf(O);
-        if (parent === null)
-          return ownKeys;
-        var parentKeys = OrdinaryMetadataKeys(parent, P);
-        if (parentKeys.length <= 0)
-          return ownKeys;
-        if (ownKeys.length <= 0)
-          return parentKeys;
-        var set2 = new _Set;
-        var keys = [];
-        for (var _i = 0, ownKeys_1 = ownKeys;_i < ownKeys_1.length; _i++) {
-          var key = ownKeys_1[_i];
-          var hasKey = set2.has(key);
-          if (!hasKey) {
-            set2.add(key);
-            keys.push(key);
-          }
-        }
-        for (var _a9 = 0, parentKeys_1 = parentKeys;_a9 < parentKeys_1.length; _a9++) {
-          var key = parentKeys_1[_a9];
-          var hasKey = set2.has(key);
-          if (!hasKey) {
-            set2.add(key);
-            keys.push(key);
-          }
-        }
-        return keys;
-      }
-      function OrdinaryOwnMetadataKeys(O, P) {
-        var provider = GetMetadataProvider(O, P, false);
-        if (!provider) {
-          return [];
-        }
-        return provider.OrdinaryOwnMetadataKeys(O, P);
-      }
-      function Type2(x) {
-        if (x === null)
-          return 1;
-        switch (typeof x) {
-          case "undefined":
-            return 0;
-          case "boolean":
-            return 2;
-          case "string":
-            return 3;
-          case "symbol":
-            return 4;
-          case "number":
-            return 5;
-          case "object":
-            return x === null ? 1 : 6;
-          default:
-            return 6;
-        }
-      }
-      function IsUndefined(x) {
-        return x === undefined;
-      }
-      function IsNull(x) {
-        return x === null;
-      }
-      function IsSymbol(x) {
-        return typeof x === "symbol";
-      }
-      function IsObject(x) {
-        return typeof x === "object" ? x !== null : typeof x === "function";
-      }
-      function ToPrimitive(input, PreferredType) {
-        switch (Type2(input)) {
-          case 0:
-            return input;
-          case 1:
-            return input;
-          case 2:
-            return input;
-          case 3:
-            return input;
-          case 4:
-            return input;
-          case 5:
-            return input;
-        }
-        var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
-        var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
-        if (exoticToPrim !== undefined) {
-          var result = exoticToPrim.call(input, hint);
-          if (IsObject(result))
-            throw new TypeError;
-          return result;
-        }
-        return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
-      }
-      function OrdinaryToPrimitive(O, hint) {
-        if (hint === "string") {
-          var toString_1 = O.toString;
-          if (IsCallable(toString_1)) {
-            var result = toString_1.call(O);
-            if (!IsObject(result))
-              return result;
-          }
-          var valueOf = O.valueOf;
-          if (IsCallable(valueOf)) {
-            var result = valueOf.call(O);
-            if (!IsObject(result))
-              return result;
-          }
-        } else {
-          var valueOf = O.valueOf;
-          if (IsCallable(valueOf)) {
-            var result = valueOf.call(O);
-            if (!IsObject(result))
-              return result;
-          }
-          var toString_2 = O.toString;
-          if (IsCallable(toString_2)) {
-            var result = toString_2.call(O);
-            if (!IsObject(result))
-              return result;
-          }
-        }
-        throw new TypeError;
-      }
-      function ToBoolean(argument) {
-        return !!argument;
-      }
-      function ToString(argument) {
-        return "" + argument;
-      }
-      function ToPropertyKey(argument) {
-        var key = ToPrimitive(argument, 3);
-        if (IsSymbol(key))
-          return key;
-        return ToString(key);
-      }
-      function IsArray(argument) {
-        return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
-      }
-      function IsCallable(argument) {
-        return typeof argument === "function";
-      }
-      function IsConstructor(argument) {
-        return typeof argument === "function";
-      }
-      function IsPropertyKey(argument) {
-        switch (Type2(argument)) {
-          case 3:
-            return true;
-          case 4:
-            return true;
-          default:
-            return false;
-        }
-      }
-      function SameValueZero(x, y) {
-        return x === y || x !== x && y !== y;
-      }
-      function GetMethod(V, P) {
-        var func = V[P];
-        if (func === undefined || func === null)
-          return;
-        if (!IsCallable(func))
-          throw new TypeError;
-        return func;
-      }
-      function GetIterator(obj) {
-        var method = GetMethod(obj, iteratorSymbol);
-        if (!IsCallable(method))
-          throw new TypeError;
-        var iterator = method.call(obj);
-        if (!IsObject(iterator))
-          throw new TypeError;
-        return iterator;
-      }
-      function IteratorValue(iterResult) {
-        return iterResult.value;
-      }
-      function IteratorStep(iterator) {
-        var result = iterator.next();
-        return result.done ? false : result;
-      }
-      function IteratorClose(iterator) {
-        var f = iterator["return"];
-        if (f)
-          f.call(iterator);
-      }
-      function OrdinaryGetPrototypeOf(O) {
-        var proto = Object.getPrototypeOf(O);
-        if (typeof O !== "function" || O === functionPrototype)
-          return proto;
-        if (proto !== functionPrototype)
-          return proto;
-        var prototype = O.prototype;
-        var prototypeProto = prototype && Object.getPrototypeOf(prototype);
-        if (prototypeProto == null || prototypeProto === Object.prototype)
-          return proto;
-        var constructor = prototypeProto.constructor;
-        if (typeof constructor !== "function")
-          return proto;
-        if (constructor === O)
-          return proto;
-        return constructor;
-      }
-      function CreateMetadataRegistry() {
-        var fallback2;
-        if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
-          fallback2 = CreateFallbackProvider(root.Reflect);
-        }
-        var first;
-        var second;
-        var rest;
-        var targetProviderMap = new _WeakMap;
-        var registry2 = {
-          registerProvider,
-          getProvider,
-          setProvider
-        };
-        return registry2;
-        function registerProvider(provider) {
-          if (!Object.isExtensible(registry2)) {
-            throw new Error("Cannot add provider to a frozen registry.");
-          }
-          switch (true) {
-            case fallback2 === provider:
-              break;
-            case IsUndefined(first):
-              first = provider;
-              break;
-            case first === provider:
-              break;
-            case IsUndefined(second):
-              second = provider;
-              break;
-            case second === provider:
-              break;
-            default:
-              if (rest === undefined)
-                rest = new _Set;
-              rest.add(provider);
-              break;
-          }
-        }
-        function getProviderNoCache(O, P) {
-          if (!IsUndefined(first)) {
-            if (first.isProviderFor(O, P))
-              return first;
-            if (!IsUndefined(second)) {
-              if (second.isProviderFor(O, P))
-                return first;
-              if (!IsUndefined(rest)) {
-                var iterator = GetIterator(rest);
-                while (true) {
-                  var next = IteratorStep(iterator);
-                  if (!next) {
-                    return;
-                  }
-                  var provider = IteratorValue(next);
-                  if (provider.isProviderFor(O, P)) {
-                    IteratorClose(iterator);
-                    return provider;
-                  }
-                }
-              }
-            }
-          }
-          if (!IsUndefined(fallback2) && fallback2.isProviderFor(O, P)) {
-            return fallback2;
-          }
-          return;
-        }
-        function getProvider(O, P) {
-          var providerMap = targetProviderMap.get(O);
-          var provider;
-          if (!IsUndefined(providerMap)) {
-            provider = providerMap.get(P);
-          }
-          if (!IsUndefined(provider)) {
-            return provider;
-          }
-          provider = getProviderNoCache(O, P);
-          if (!IsUndefined(provider)) {
-            if (IsUndefined(providerMap)) {
-              providerMap = new _Map;
-              targetProviderMap.set(O, providerMap);
-            }
-            providerMap.set(P, provider);
-          }
-          return provider;
-        }
-        function hasProvider(provider) {
-          if (IsUndefined(provider))
-            throw new TypeError;
-          return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
-        }
-        function setProvider(O, P, provider) {
-          if (!hasProvider(provider)) {
-            throw new Error("Metadata provider not registered.");
-          }
-          var existingProvider = getProvider(O, P);
-          if (existingProvider !== provider) {
-            if (!IsUndefined(existingProvider)) {
-              return false;
-            }
-            var providerMap = targetProviderMap.get(O);
-            if (IsUndefined(providerMap)) {
-              providerMap = new _Map;
-              targetProviderMap.set(O, providerMap);
-            }
-            providerMap.set(P, provider);
-          }
-          return true;
-        }
-      }
-      function GetOrCreateMetadataRegistry() {
-        var metadataRegistry2;
-        if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
-          metadataRegistry2 = root.Reflect[registrySymbol];
-        }
-        if (IsUndefined(metadataRegistry2)) {
-          metadataRegistry2 = CreateMetadataRegistry();
-        }
-        if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
-          Object.defineProperty(root.Reflect, registrySymbol, {
-            enumerable: false,
-            configurable: false,
-            writable: false,
-            value: metadataRegistry2
-          });
-        }
-        return metadataRegistry2;
-      }
-      function CreateMetadataProvider(registry2) {
-        var metadata2 = new _WeakMap;
-        var provider = {
-          isProviderFor: function(O, P) {
-            var targetMetadata = metadata2.get(O);
-            if (IsUndefined(targetMetadata))
-              return false;
-            return targetMetadata.has(P);
-          },
-          OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
-          OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
-          OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
-          OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
-          OrdinaryDeleteMetadata
-        };
-        metadataRegistry.registerProvider(provider);
-        return provider;
-        function GetOrCreateMetadataMap(O, P, Create) {
-          var targetMetadata = metadata2.get(O);
-          var createdTargetMetadata = false;
-          if (IsUndefined(targetMetadata)) {
-            if (!Create)
-              return;
-            targetMetadata = new _Map;
-            metadata2.set(O, targetMetadata);
-            createdTargetMetadata = true;
-          }
-          var metadataMap = targetMetadata.get(P);
-          if (IsUndefined(metadataMap)) {
-            if (!Create)
-              return;
-            metadataMap = new _Map;
-            targetMetadata.set(P, metadataMap);
-            if (!registry2.setProvider(O, P, provider)) {
-              targetMetadata.delete(P);
-              if (createdTargetMetadata) {
-                metadata2.delete(O);
-              }
-              throw new Error("Wrong provider for target.");
-            }
-          }
-          return metadataMap;
-        }
-        function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
-          var metadataMap = GetOrCreateMetadataMap(O, P, false);
-          if (IsUndefined(metadataMap))
-            return false;
-          return ToBoolean(metadataMap.has(MetadataKey));
-        }
-        function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
-          var metadataMap = GetOrCreateMetadataMap(O, P, false);
-          if (IsUndefined(metadataMap))
-            return;
-          return metadataMap.get(MetadataKey);
-        }
-        function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
-          var metadataMap = GetOrCreateMetadataMap(O, P, true);
-          metadataMap.set(MetadataKey, MetadataValue);
-        }
-        function OrdinaryOwnMetadataKeys2(O, P) {
-          var keys = [];
-          var metadataMap = GetOrCreateMetadataMap(O, P, false);
-          if (IsUndefined(metadataMap))
-            return keys;
-          var keysObj = metadataMap.keys();
-          var iterator = GetIterator(keysObj);
-          var k = 0;
-          while (true) {
-            var next = IteratorStep(iterator);
-            if (!next) {
-              keys.length = k;
-              return keys;
-            }
-            var nextValue = IteratorValue(next);
-            try {
-              keys[k] = nextValue;
-            } catch (e) {
-              try {
-                IteratorClose(iterator);
-              } finally {
-                throw e;
-              }
-            }
-            k++;
-          }
-        }
-        function OrdinaryDeleteMetadata(MetadataKey, O, P) {
-          var metadataMap = GetOrCreateMetadataMap(O, P, false);
-          if (IsUndefined(metadataMap))
-            return false;
-          if (!metadataMap.delete(MetadataKey))
-            return false;
-          if (metadataMap.size === 0) {
-            var targetMetadata = metadata2.get(O);
-            if (!IsUndefined(targetMetadata)) {
-              targetMetadata.delete(P);
-              if (targetMetadata.size === 0) {
-                metadata2.delete(targetMetadata);
-              }
-            }
-          }
-          return true;
-        }
-      }
-      function CreateFallbackProvider(reflect) {
-        var { defineMetadata: defineMetadata2, hasOwnMetadata: hasOwnMetadata2, getOwnMetadata: getOwnMetadata2, getOwnMetadataKeys: getOwnMetadataKeys2, deleteMetadata: deleteMetadata2 } = reflect;
-        var metadataOwner = new _WeakMap;
-        var provider = {
-          isProviderFor: function(O, P) {
-            var metadataPropertySet = metadataOwner.get(O);
-            if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
-              return true;
-            }
-            if (getOwnMetadataKeys2(O, P).length) {
-              if (IsUndefined(metadataPropertySet)) {
-                metadataPropertySet = new _Set;
-                metadataOwner.set(O, metadataPropertySet);
-              }
-              metadataPropertySet.add(P);
-              return true;
-            }
-            return false;
-          },
-          OrdinaryDefineOwnMetadata: defineMetadata2,
-          OrdinaryHasOwnMetadata: hasOwnMetadata2,
-          OrdinaryGetOwnMetadata: getOwnMetadata2,
-          OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
-          OrdinaryDeleteMetadata: deleteMetadata2
-        };
-        return provider;
-      }
-      function GetMetadataProvider(O, P, Create) {
-        var registeredProvider = metadataRegistry.getProvider(O, P);
-        if (!IsUndefined(registeredProvider)) {
-          return registeredProvider;
-        }
-        if (Create) {
-          if (metadataRegistry.setProvider(O, P, metadataProvider)) {
-            return metadataProvider;
-          }
-          throw new Error("Illegal state.");
-        }
-        return;
-      }
-      function CreateMapPolyfill() {
-        var cacheSentinel = {};
-        var arraySentinel = [];
-        var MapIterator = function() {
-          function MapIterator2(keys, values2, selector) {
-            this._index = 0;
-            this._keys = keys;
-            this._values = values2;
-            this._selector = selector;
-          }
-          MapIterator2.prototype["@@iterator"] = function() {
-            return this;
-          };
-          MapIterator2.prototype[iteratorSymbol] = function() {
-            return this;
-          };
-          MapIterator2.prototype.next = function() {
-            var index2 = this._index;
-            if (index2 >= 0 && index2 < this._keys.length) {
-              var result = this._selector(this._keys[index2], this._values[index2]);
-              if (index2 + 1 >= this._keys.length) {
-                this._index = -1;
-                this._keys = arraySentinel;
-                this._values = arraySentinel;
-              } else {
-                this._index++;
-              }
-              return { value: result, done: false };
-            }
-            return { value: undefined, done: true };
-          };
-          MapIterator2.prototype.throw = function(error53) {
-            if (this._index >= 0) {
-              this._index = -1;
-              this._keys = arraySentinel;
-              this._values = arraySentinel;
-            }
-            throw error53;
-          };
-          MapIterator2.prototype.return = function(value) {
-            if (this._index >= 0) {
-              this._index = -1;
-              this._keys = arraySentinel;
-              this._values = arraySentinel;
-            }
-            return { value, done: true };
-          };
-          return MapIterator2;
-        }();
-        var Map2 = function() {
-          function Map3() {
-            this._keys = [];
-            this._values = [];
-            this._cacheKey = cacheSentinel;
-            this._cacheIndex = -2;
-          }
-          Object.defineProperty(Map3.prototype, "size", {
-            get: function() {
-              return this._keys.length;
-            },
-            enumerable: true,
-            configurable: true
-          });
-          Map3.prototype.has = function(key) {
-            return this._find(key, false) >= 0;
-          };
-          Map3.prototype.get = function(key) {
-            var index2 = this._find(key, false);
-            return index2 >= 0 ? this._values[index2] : undefined;
-          };
-          Map3.prototype.set = function(key, value) {
-            var index2 = this._find(key, true);
-            this._values[index2] = value;
-            return this;
-          };
-          Map3.prototype.delete = function(key) {
-            var index2 = this._find(key, false);
-            if (index2 >= 0) {
-              var size3 = this._keys.length;
-              for (var i = index2 + 1;i < size3; i++) {
-                this._keys[i - 1] = this._keys[i];
-                this._values[i - 1] = this._values[i];
-              }
-              this._keys.length--;
-              this._values.length--;
-              if (SameValueZero(key, this._cacheKey)) {
-                this._cacheKey = cacheSentinel;
-                this._cacheIndex = -2;
-              }
-              return true;
-            }
-            return false;
-          };
-          Map3.prototype.clear = function() {
-            this._keys.length = 0;
-            this._values.length = 0;
-            this._cacheKey = cacheSentinel;
-            this._cacheIndex = -2;
-          };
-          Map3.prototype.keys = function() {
-            return new MapIterator(this._keys, this._values, getKey);
-          };
-          Map3.prototype.values = function() {
-            return new MapIterator(this._keys, this._values, getValue);
-          };
-          Map3.prototype.entries = function() {
-            return new MapIterator(this._keys, this._values, getEntry);
-          };
-          Map3.prototype["@@iterator"] = function() {
-            return this.entries();
-          };
-          Map3.prototype[iteratorSymbol] = function() {
-            return this.entries();
-          };
-          Map3.prototype._find = function(key, insert) {
-            if (!SameValueZero(this._cacheKey, key)) {
-              this._cacheIndex = -1;
-              for (var i = 0;i < this._keys.length; i++) {
-                if (SameValueZero(this._keys[i], key)) {
-                  this._cacheIndex = i;
-                  break;
-                }
-              }
-            }
-            if (this._cacheIndex < 0 && insert) {
-              this._cacheIndex = this._keys.length;
-              this._keys.push(key);
-              this._values.push(undefined);
-            }
-            return this._cacheIndex;
-          };
-          return Map3;
-        }();
-        return Map2;
-        function getKey(key, _) {
-          return key;
-        }
-        function getValue(_, value) {
-          return value;
-        }
-        function getEntry(key, value) {
-          return [key, value];
-        }
-      }
-      function CreateSetPolyfill() {
-        var Set3 = function() {
-          function Set4() {
-            this._map = new _Map;
-          }
-          Object.defineProperty(Set4.prototype, "size", {
-            get: function() {
-              return this._map.size;
-            },
-            enumerable: true,
-            configurable: true
-          });
-          Set4.prototype.has = function(value) {
-            return this._map.has(value);
-          };
-          Set4.prototype.add = function(value) {
-            return this._map.set(value, value), this;
-          };
-          Set4.prototype.delete = function(value) {
-            return this._map.delete(value);
-          };
-          Set4.prototype.clear = function() {
-            this._map.clear();
-          };
-          Set4.prototype.keys = function() {
-            return this._map.keys();
-          };
-          Set4.prototype.values = function() {
-            return this._map.keys();
-          };
-          Set4.prototype.entries = function() {
-            return this._map.entries();
-          };
-          Set4.prototype["@@iterator"] = function() {
-            return this.keys();
-          };
-          Set4.prototype[iteratorSymbol] = function() {
-            return this.keys();
-          };
-          return Set4;
-        }();
-        return Set3;
-      }
-      function CreateWeakMapPolyfill() {
-        var UUID_SIZE = 16;
-        var keys = HashMap.create();
-        var rootKey = CreateUniqueKey();
-        return function() {
-          function WeakMap2() {
-            this._key = CreateUniqueKey();
-          }
-          WeakMap2.prototype.has = function(target) {
-            var table = GetOrCreateWeakMapTable(target, false);
-            return table !== undefined ? HashMap.has(table, this._key) : false;
-          };
-          WeakMap2.prototype.get = function(target) {
-            var table = GetOrCreateWeakMapTable(target, false);
-            return table !== undefined ? HashMap.get(table, this._key) : undefined;
-          };
-          WeakMap2.prototype.set = function(target, value) {
-            var table = GetOrCreateWeakMapTable(target, true);
-            table[this._key] = value;
-            return this;
-          };
-          WeakMap2.prototype.delete = function(target) {
-            var table = GetOrCreateWeakMapTable(target, false);
-            return table !== undefined ? delete table[this._key] : false;
-          };
-          WeakMap2.prototype.clear = function() {
-            this._key = CreateUniqueKey();
-          };
-          return WeakMap2;
-        }();
-        function CreateUniqueKey() {
-          var key;
-          do
-            key = "@@WeakMap@@" + CreateUUID();
-          while (HashMap.has(keys, key));
-          keys[key] = true;
-          return key;
-        }
-        function GetOrCreateWeakMapTable(target, create) {
-          if (!hasOwn4.call(target, rootKey)) {
-            if (!create)
-              return;
-            Object.defineProperty(target, rootKey, { value: HashMap.create() });
-          }
-          return target[rootKey];
-        }
-        function FillRandomBytes(buffer, size3) {
-          for (var i = 0;i < size3; ++i)
-            buffer[i] = Math.random() * 255 | 0;
-          return buffer;
-        }
-        function GenRandomBytes(size3) {
-          if (typeof Uint8Array === "function") {
-            var array2 = new Uint8Array(size3);
-            if (typeof crypto !== "undefined") {
-              crypto.getRandomValues(array2);
-            } else if (typeof msCrypto !== "undefined") {
-              msCrypto.getRandomValues(array2);
-            } else {
-              FillRandomBytes(array2, size3);
-            }
-            return array2;
-          }
-          return FillRandomBytes(new Array(size3), size3);
-        }
-        function CreateUUID() {
-          var data = GenRandomBytes(UUID_SIZE);
-          data[6] = data[6] & 79 | 64;
-          data[8] = data[8] & 191 | 128;
-          var result = "";
-          for (var offset = 0;offset < UUID_SIZE; ++offset) {
-            var byte = data[offset];
-            if (offset === 4 || offset === 6 || offset === 8)
-              result += "-";
-            if (byte < 16)
-              result += "0";
-            result += byte.toString(16).toLowerCase();
-          }
-          return result;
-        }
-      }
-      function MakeDictionary(obj) {
-        obj.__ = undefined;
-        delete obj.__;
-        return obj;
-      }
-    });
-  })(Reflect2 || (Reflect2 = {}));
-});
-
 // node_modules/.bun/@peculiar+asn1-cms@2.6.1/node_modules/@peculiar/asn1-cms/build/es2015/issuer_and_serial_number.js
 class IssuerAndSerialNumber {
   constructor(params = {}) {
@@ -343948,13 +343953,17 @@ var init_src25 = __esm(async () => {
   await init_run_tui();
 });
 
+// packages/agenter/src/bin/agenter.ts
+var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
+
 // packages/cli/src/run-cli.ts
 import { spawn as spawnChildProcess } from "child_process";
-import { existsSync as existsSync38 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync38, mkdirSync as mkdirSync38, openSync as openSync3, readFileSync as readFileSync30 } from "fs";
+import { createRequire as createRequire5 } from "module";
 import { request as httpRequest2 } from "http";
 import { request as httpsRequest } from "https";
 import { homedir as homedir25 } from "os";
-import { join as join64, resolve as resolve57 } from "path";
+import { dirname as dirname44, join as join64, resolve as resolve57 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 import { suffix as suffix4 } from "bun:ffi";
 
@@ -348821,6 +348830,7 @@ var productCommandDescriptors = [
   productCommandDescriptorSchema.parse({
     productId: "cli-shell",
     command: "shell",
+    description: "run cli-shell terminal workspace",
     packageName: "agenter-ext-shell",
     bin: {
       name: "agenter-cli-shell",
@@ -348837,6 +348847,7 @@ var productCommandDescriptors = [
   productCommandDescriptorSchema.parse({
     productId: "studio",
     command: "studio",
+    description: "run Studio web UI",
     packageName: "agenter-ext-studio",
     bin: {
       name: "agenter-studio",
@@ -348852,6 +348863,7 @@ var productCommandDescriptors = [
   })
 ];
 var descriptorByCommand = new Map(productCommandDescriptors.map((descriptor) => [descriptor.command, descriptor]));
+var listProductCommandDescriptors = () => productCommandDescriptors;
 var resolveProductCommandDescriptor = (command2) => descriptorByCommand.get(command2) ?? null;
 
 // packages/cli/src/product-command-launcher.ts
@@ -349052,6 +349064,13 @@ var buildProductLaunchEnv = (input) => {
 };
 var resolveProductPackageRunner = (env2 = process.env) => env2.AGENTER_PRODUCT_PACKAGE_RUNNER?.trim() || DEFAULT_PRODUCT_PACKAGE_RUNNER;
 var isProductMetadataOnlyArgv = (productArgv) => productArgv.some((token) => metadataOnlyTokens.has(token));
+var applyProductCommandsToYargs = (builder) => {
+  let next = builder;
+  for (const descriptor of listProductCommandDescriptors()) {
+    next = next.command(descriptor.command, descriptor.description ?? `run ${descriptor.productId}`, (commandBuilder) => commandBuilder, () => {});
+  }
+  return next;
+};
 var buildProductProcessCommand = (target, descriptor, productArgv, env2 = process.env) => {
   if (target.source !== "remote") {
     return [BUN_BIN, "run", target.binPath, ...productArgv];
@@ -349070,6 +349089,7 @@ init_daemon_runtime_descriptor();
 var INTERNAL_DAEMON_FOREGROUND_ENV = "AGENTER_INTERNAL_DAEMON_FOREGROUND";
 var BUNDLED_ASSETS_ROOT_ENV3 = "AGENTER_BUNDLED_ASSETS_ROOT";
 var MANAGED_DAEMON_START_TIMEOUT_MS = 15000;
+var packageJson = createRequire5(import.meta.url)("../package.json");
 var waitForSignal = async (cleanup) => {
   await new Promise((resolve58) => {
     const onSignal = async () => {
@@ -349090,6 +349110,13 @@ var resolveLauncherHomeDir = () => process.env.HOME || homedir25();
 var resolveLauncherOwnedAuthServiceDataDir = () => join64(resolveLauncherHomeDir(), ".agenter", "launcher-auth-service");
 var resolveDaemonHealthLabel = (args) => `http://${args.host}:${args.port}/health`;
 var resolveCliEntryPath = () => resolve57(import.meta.dir, "bin", "agenter.ts");
+var resolveCurrentCliEntrypointArgv = () => {
+  const entrypoint = process.argv[1];
+  if (entrypoint && existsSync38(entrypoint)) {
+    return [entrypoint];
+  }
+  return ["run", resolveCliEntryPath()];
+};
 var resolveBunExecutable = () => Bun.which("bun") ?? process.execPath;
 var resolveBundledAssetsRoot2 = () => process.env[BUNDLED_ASSETS_ROOT_ENV3]?.trim() || null;
 var resolveBundledAssetPath2 = (...segments) => {
@@ -349150,7 +349177,7 @@ var sameDaemonAuthority = (descriptor, requested) => descriptor.host === request
 var resolveDaemonCommandAction = (value) => value === "stop" || value === "restart" ? value : "start";
 var isForegroundDaemonServeRequested = () => process.env[INTERNAL_DAEMON_FOREGROUND_ENV] === "1";
 var buildDaemonServeArgv = (args) => {
-  const argv = ["run", resolveCliEntryPath(), "daemon", "start", "--host", args.host, "--port", String(args.port)];
+  const argv = [...resolveCurrentCliEntrypointArgv(), "daemon", "start", "--host", args.host, "--port", String(args.port)];
   if (args.authServiceEndpoint) {
     argv.push("--auth-service-endpoint", args.authServiceEndpoint);
   }
@@ -349165,21 +349192,41 @@ var buildDaemonServeArgv = (args) => {
   }
   return argv;
 };
+var readLogTail = (path7, maxBytes = 16384) => {
+  try {
+    const text4 = readFileSync30(path7, "utf8");
+    return text4.length > maxBytes ? text4.slice(-maxBytes) : text4;
+  } catch {
+    return "";
+  }
+};
 var spawnManagedDaemonProcess = (args) => {
-  const child = spawnChildProcess(resolveBunExecutable(), buildDaemonServeArgv(args), {
-    cwd: process.cwd(),
-    detached: true,
-    stdio: "ignore",
-    env: {
-      ...process.env,
-      [INTERNAL_DAEMON_FOREGROUND_ENV]: "1"
+  const logPath = resolveDaemonLogPath(resolveLauncherHomeDir(), args);
+  mkdirSync38(dirname44(logPath), { recursive: true });
+  const logFd = openSync3(logPath, "a");
+  const child = (() => {
+    try {
+      return spawnChildProcess(resolveBunExecutable(), buildDaemonServeArgv(args), {
+        cwd: process.cwd(),
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+        env: {
+          ...process.env,
+          [INTERNAL_DAEMON_FOREGROUND_ENV]: "1"
+        }
+      });
+    } finally {
+      closeSync3(logFd);
     }
-  });
+  })();
   child.unref();
   if (typeof child.pid !== "number" || child.pid <= 0) {
     throw new Error("failed to spawn background daemon process");
   }
-  return child.pid;
+  return {
+    pid: child.pid,
+    logPath
+  };
 };
 var waitForManagedDaemonHealthy = async (authority, pid, timeoutMs = MANAGED_DAEMON_START_TIMEOUT_MS) => {
   const startedAt = Date.now();
@@ -349255,13 +349302,20 @@ var runDaemonStartCommand = async (args) => {
       return;
     }
   }
-  const pid = spawnManagedDaemonProcess(args);
+  const { pid, logPath } = spawnManagedDaemonProcess(args);
   const status = await waitForManagedDaemonHealthy(requested, pid);
   if (status === "healthy") {
     console.log(`agenter daemon started in background on ${requested.host}:${requested.port}`);
+    console.log(`daemon log: ${logPath}`);
     return;
   }
   console.error(status === "exited" ? `background daemon process ${pid} exited before becoming healthy on ${requested.host}:${requested.port}` : `timed out waiting for background daemon ${pid} to become healthy on ${requested.host}:${requested.port}`);
+  console.error(`daemon log: ${logPath}`);
+  const logTail = readLogTail(logPath).trim();
+  if (logTail.length > 0) {
+    console.error("daemon log tail:");
+    console.error(logTail);
+  }
   process.exitCode = 1;
 };
 var runDaemonStopCommand = async () => {
@@ -349504,7 +349558,7 @@ var runCli = async (argvInput = process.argv) => {
   if (await launchProductCommand(rawArgs)) {
     return;
   }
-  const argv = await yargs_default(rawArgs).scriptName("agenter").option("host", {
+  const argv = await applyProductCommandsToYargs(yargs_default(rawArgs).scriptName("agenter").version(packageJson.version ?? "unknown").option("host", {
     type: "string",
     default: "127.0.0.1",
     describe: "daemon host"
@@ -349512,7 +349566,7 @@ var runCli = async (argvInput = process.argv) => {
     type: "number",
     default: 4580,
     describe: "daemon port"
-  }).command(["auth-service", "profile-service"], "start standalone auth-service (profile-service remains a deprecated compatibility alias)", (builder) => builder.option("port", {
+  })).command(["auth-service", "profile-service"], "start standalone auth-service (profile-service remains a deprecated compatibility alias)", (builder) => builder.option("port", {
     type: "number",
     default: 4591,
     describe: "auth-service port"