coderifts 1.8.3 → 1.9.0

package/dist/cli.js

@@ -3007,7 +3007,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "coderifts",
-      version: "1.8.3",
+      version: "1.9.0",
       description: "Detect breaking API changes from the command line. Works locally or with the CodeRifts cloud API.",
       author: "CodeRifts <hello@coderifts.com>",
       license: "MIT",
@@ -3050,6 +3050,7 @@ var require_package = __commonJS({
         test: "node --test test/*.test.js"
       },
       dependencies: {
+        "@coderifts/agent-guard": "^1.6.0",
         chalk: "^4.1.2",
         "cli-table3": "^0.6.4",
         commander: "^12.0.0",
@@ -3061,7 +3062,8 @@ var require_package = __commonJS({
       overrides: {
         "z-schema": "^7.2.0",
         "json-schema-ref-parser": "npm:@apidevtools/json-schema-ref-parser@^11.7.3",
-        "form-data": "^4.0.6"
+        "form-data": "^4.0.6",
+        axios: ">=1.18.0"
       },
       devDependencies: {
         esbuild: "^0.28.1"
@@ -30018,6 +30020,7 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+    var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
     function getParseError(parsed, matches) {
       if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
@@ -30047,6 +30050,11 @@ var require_fast_uri = __commonJS({
           uri = "//" + uri;
         }
       }
+      const authorityMatch = uri.match(AUTHORITY_PREFIX);
+      if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
+        parsed.error = "URI authority must not contain a literal backslash.";
+        malformedAuthorityOrPort = true;
+      }
       const matches = uri.match(URI_PARSE);
       if (matches) {
         parsed.scheme = matches[1];
@@ -30090,7 +30098,7 @@ var require_fast_uri = __commonJS({
         if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
           if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
             try {
-              parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
+              parsed.host = new URL("http://" + parsed.host).hostname;
             } catch (e) {
               parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
             }
@@ -60563,6 +60571,25 @@ var require_axios = __commonJS({
       iterator,
       toStringTag
     } = Symbol;
+    var hasOwnProperty = (({
+      hasOwnProperty: hasOwnProperty2
+    }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
+    var hasOwnInPrototypeChain = (thing, prop) => {
+      let obj = thing;
+      const seen = [];
+      while (obj != null && obj !== Object.prototype) {
+        if (seen.indexOf(obj) !== -1) {
+          return false;
+        }
+        seen.push(obj);
+        if (hasOwnProperty(obj, prop)) {
+          return true;
+        }
+        obj = getPrototypeOf(obj);
+      }
+      return false;
+    };
+    var getSafeProp = (obj, prop) => obj != null && hasOwnInPrototypeChain(obj, prop) ? obj[prop] : void 0;
     var kindOf = /* @__PURE__ */ ((cache) => (thing) => {
       const str = toString.call(thing);
       return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
@@ -60595,11 +60622,14 @@ var require_axios = __commonJS({
     var isObject = (thing) => thing !== null && typeof thing === "object";
     var isBoolean = (thing) => thing === true || thing === false;
     var isPlainObject = (val) => {
-      if (kindOf(val) !== "object") {
+      if (!isObject(val)) {
         return false;
       }
       const prototype2 = getPrototypeOf(val);
-      return (prototype2 === null || prototype2 === Object.prototype || Object.getPrototypeOf(prototype2) === null) && !(toStringTag in val) && !(iterator in val);
+      return (prototype2 === null || prototype2 === Object.prototype || getPrototypeOf(prototype2) === null) && // Treat any genuine (non-Object.prototype-polluted) Symbol.toStringTag or
+      // Symbol.iterator as evidence the value is a tagged/iterable type rather
+      // than a plain object, while ignoring keys injected onto Object.prototype.
+      !hasOwnInPrototypeChain(val, toStringTag) && !hasOwnInPrototypeChain(val, iterator);
     };
     var isEmptyObject = (val) => {
       if (!isObject(val) || isBuffer(val)) {
@@ -60852,9 +60882,6 @@ var require_axios = __commonJS({
         return p1.toUpperCase() + p2;
       });
     };
-    var hasOwnProperty = (({
-      hasOwnProperty: hasOwnProperty2
-    }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
     var {
       propertyIsEnumerable
     } = Object.prototype;
@@ -60955,6 +60982,7 @@ var require_axios = __commonJS({
     })(typeof setImmediate === "function", isFunction$1(_global.postMessage));
     var asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process !== "undefined" && process.nextTick || _setImmediate;
     var isIterable = (thing) => thing != null && isFunction$1(thing[iterator]);
+    var isSafeIterable = (thing) => thing != null && hasOwnInPrototypeChain(thing, iterator) && isIterable(thing);
     var utils$1 = {
       isArray,
       isArrayBuffer,
@@ -61000,6 +61028,8 @@ var require_axios = __commonJS({
       hasOwnProperty,
       hasOwnProp: hasOwnProperty,
       // an alias to avoid ESLint no-prototype-builtins detection
+      hasOwnInPrototypeChain,
+      getSafeProp,
       reduceDescriptors,
       freezeMethods,
       toObjectSet,
@@ -61015,7 +61045,8 @@ var require_axios = __commonJS({
       isThenable,
       setImmediate: _setImmediate,
       asap,
-      isIterable
+      isIterable,
+      isSafeIterable
     };
     var ignoreDuplicateOf = utils$1.toObjectSet(["age", "authorization", "content-length", "content-type", "etag", "expires", "from", "host", "if-modified-since", "if-unmodified-since", "last-modified", "location", "max-forwards", "proxy-authorization", "referer", "retry-after", "user-agent"]);
     var parseHeaders = (rawHeaders) => {
@@ -61153,13 +61184,19 @@ var require_axios = __commonJS({
           setHeaders(header, valueOrRewrite);
         } else if (utils$1.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
           setHeaders(parseHeaders(header), valueOrRewrite);
-        } else if (utils$1.isObject(header) && utils$1.isIterable(header)) {
-          let obj = {}, dest, key;
+        } else if (utils$1.isObject(header) && utils$1.isSafeIterable(header)) {
+          let obj = /* @__PURE__ */ Object.create(null), dest, key;
           for (const entry of header) {
             if (!utils$1.isArray(entry)) {
               throw new TypeError("Object iterator must return a key-value pair");
             }
-            obj[key = entry[0]] = (dest = obj[key]) ? utils$1.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]] : entry[1];
+            key = entry[0];
+            if (utils$1.hasOwnProp(obj, key)) {
+              dest = obj[key];
+              obj[key] = utils$1.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]];
+            } else {
+              obj[key] = entry[1];
+            }
           }
           setHeaders(obj, valueOrRewrite);
         } else {
@@ -61364,7 +61401,13 @@ var require_axios = __commonJS({
     var AxiosError = class _AxiosError extends Error {
       static from(error, code, config, request, response, customProps) {
         const axiosError = new _AxiosError(error.message, code || error.code, config, request, response);
-        axiosError.cause = error;
+        Object.defineProperty(axiosError, "cause", {
+          __proto__: null,
+          value: error,
+          writable: true,
+          enumerable: false,
+          configurable: true
+        });
         axiosError.name = error.name;
         if (error.status != null && axiosError.status == null) {
           axiosError.status = error.status;
@@ -61441,6 +61484,7 @@ var require_axios = __commonJS({
     AxiosError.ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
     AxiosError.ERR_INVALID_URL = "ERR_INVALID_URL";
     AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED = "ERR_FORM_DATA_DEPTH_EXCEEDED";
+    var DEFAULT_FORM_DATA_MAX_DEPTH = 100;
     function isVisitable(thing) {
       return utils$1.isPlainObject(thing) || utils$1.isArray(thing);
     }
@@ -61477,8 +61521,9 @@ var require_axios = __commonJS({
       const dots = options.dots;
       const indexes = options.indexes;
       const _Blob = options.Blob || typeof Blob !== "undefined" && Blob;
-      const maxDepth = options.maxDepth === void 0 ? 100 : options.maxDepth;
+      const maxDepth = options.maxDepth === void 0 ? DEFAULT_FORM_DATA_MAX_DEPTH : options.maxDepth;
       const useBlob = _Blob && utils$1.isSpecCompliantForm(formData);
+      const stack = [];
       if (!utils$1.isFunction(visitor)) {
         throw new TypeError("visitor must be a function");
       }
@@ -61494,10 +61539,38 @@ var require_axios = __commonJS({
           throw new AxiosError("Blob is not supported. Use a Buffer instead.");
         }
         if (utils$1.isArrayBuffer(value) || utils$1.isTypedArray(value)) {
-          return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
+          if (useBlob && typeof _Blob === "function") {
+            return new _Blob([value]);
+          }
+          if (typeof Buffer !== "undefined") {
+            return Buffer.from(value);
+          }
+          throw new AxiosError("Blob is not supported. Use a Buffer instead.", AxiosError.ERR_NOT_SUPPORT);
         }
         return value;
       }
+      function throwIfMaxDepthExceeded(depth) {
+        if (depth > maxDepth) {
+          throw new AxiosError("Object is too deeply nested (" + depth + " levels). Max depth: " + maxDepth, AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED);
+        }
+      }
+      function stringifyWithDepthLimit(value, depth) {
+        if (maxDepth === Infinity) {
+          return JSON.stringify(value);
+        }
+        const ancestors = [];
+        return JSON.stringify(value, function limitDepth(_key, currentValue) {
+          if (!utils$1.isObject(currentValue)) {
+            return currentValue;
+          }
+          while (ancestors.length && ancestors[ancestors.length - 1] !== this) {
+            ancestors.pop();
+          }
+          ancestors.push(currentValue);
+          throwIfMaxDepthExceeded(depth + ancestors.length - 1);
+          return currentValue;
+        });
+      }
       function defaultVisitor(value, key, path2) {
         let arr = value;
         if (utils$1.isReactNative(formData) && utils$1.isReactNativeBlob(value)) {
@@ -61507,7 +61580,7 @@ var require_axios = __commonJS({
         if (value && !path2 && typeof value === "object") {
           if (utils$1.endsWith(key, "{}")) {
             key = metaTokens ? key : key.slice(0, -2);
-            value = JSON.stringify(value);
+            value = stringifyWithDepthLimit(value, 1);
           } else if (utils$1.isArray(value) && isFlatArray(value) || (utils$1.isFileList(value) || utils$1.endsWith(key, "[]")) && (arr = utils$1.toArray(value))) {
             key = removeBrackets(key);
             arr.forEach(function each(el, index) {
@@ -61526,7 +61599,6 @@ var require_axios = __commonJS({
         formData.append(renderKey(path2, key, dots), convertValue(value));
         return false;
       }
-      const stack = [];
       const exposedHelpers = Object.assign(predicates, {
         defaultVisitor,
         convertValue,
@@ -61534,9 +61606,7 @@ var require_axios = __commonJS({
       });
       function build(value, path2, depth = 0) {
         if (utils$1.isUndefined(value)) return;
-        if (depth > maxDepth) {
-          throw new AxiosError("Object is too deeply nested (" + depth + " levels). Max depth: " + maxDepth, AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED);
-        }
+        throwIfMaxDepthExceeded(depth);
         if (stack.indexOf(value) !== -1) {
           throw new Error("Circular reference detected in " + path2.join("."));
         }
@@ -61577,9 +61647,7 @@ var require_axios = __commonJS({
       this._pairs.push([name, value]);
     };
     prototype.toString = function toString2(encoder) {
-      const _encode = encoder ? function(value) {
-        return encoder.call(this, value, encode$1);
-      } : encode$1;
+      const _encode = encoder ? (value) => encoder.call(this, value, encode$1) : encode$1;
       return this._pairs.map(function each(pair) {
         return _encode(pair[0]) + "=" + _encode(pair[1]);
       }, "").join("&");
@@ -61591,11 +61659,12 @@ var require_axios = __commonJS({
       if (!params) {
         return url2;
       }
-      const _encode = options && options.encode || encode;
+      url2 = url2 || "";
       const _options = utils$1.isFunction(options) ? {
         serialize: options
       } : options;
-      const serializeFn = _options && _options.serialize;
+      const _encode = utils$1.getSafeProp(_options, "encode") || encode;
+      const serializeFn = utils$1.getSafeProp(_options, "serialize");
       let serializedParams;
       if (serializeFn) {
         serializedParams = serializeFn(params, _options);
@@ -61678,9 +61747,10 @@ var require_axios = __commonJS({
       forcedJSONParsing: true,
       clarifyTimeoutError: false,
       legacyInterceptorReqResOrdering: true,
-      advertiseZstdAcceptEncoding: false
+      advertiseZstdAcceptEncoding: false,
+      validateStatusUndefinedResolves: true
     };
-    var URLSearchParams = url.URLSearchParams;
+    var URLSearchParams2 = url.URLSearchParams;
     var ALPHA = "abcdefghijklmnopqrstuvwxyz";
     var DIGIT = "0123456789";
     var ALPHABET = {
@@ -61703,7 +61773,7 @@ var require_axios = __commonJS({
     var platform$1 = {
       isNode: true,
       classes: {
-        URLSearchParams,
+        URLSearchParams: URLSearchParams2,
         FormData: FormData$1,
         Blob: typeof Blob !== "undefined" && Blob || null
       },
@@ -61743,10 +61813,21 @@ var require_axios = __commonJS({
         ...options
       });
     }
+    var MAX_DEPTH = DEFAULT_FORM_DATA_MAX_DEPTH;
+    function throwIfDepthExceeded(index) {
+      if (index > MAX_DEPTH) {
+        throw new AxiosError("FormData field is too deeply nested (" + index + " levels). Max depth: " + MAX_DEPTH, AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED);
+      }
+    }
     function parsePropPath(name) {
-      return utils$1.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
-        return match[0] === "[]" ? "" : match[1] || match[0];
-      });
+      const path2 = [];
+      const pattern = /\w+|\[(\w*)]/g;
+      let match;
+      while ((match = pattern.exec(name)) !== null) {
+        throwIfDepthExceeded(path2.length);
+        path2.push(match[0] === "[]" ? "" : match[1] || match[0]);
+      }
+      return path2;
     }
     function arrayToObject(arr) {
       const obj = {};
@@ -61762,6 +61843,7 @@ var require_axios = __commonJS({
     }
     function formDataToJSON(formData) {
       function buildPath(path2, value, target, index) {
+        throwIfDepthExceeded(index);
         let name = path2[index++];
         if (name === "__proto__") return true;
         const isNumericKey = Number.isFinite(+name);
@@ -61948,9 +62030,28 @@ var require_axios = __commonJS({
     function combineURLs(baseURL, relativeURL) {
       return relativeURL ? baseURL.replace(/\/?\/$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
     }
-    function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
+    var malformedHttpProtocol = /^https?:(?!\/\/)/i;
+    var httpProtocolControlCharacters = /[\t\n\r]/g;
+    function stripLeadingC0ControlOrSpace(url2) {
+      let i = 0;
+      while (i < url2.length && url2.charCodeAt(i) <= 32) {
+        i++;
+      }
+      return url2.slice(i);
+    }
+    function normalizeURLForProtocolCheck(url2) {
+      return stripLeadingC0ControlOrSpace(url2).replace(httpProtocolControlCharacters, "");
+    }
+    function assertValidHttpProtocolURL(url2, config) {
+      if (typeof url2 === "string" && malformedHttpProtocol.test(normalizeURLForProtocolCheck(url2))) {
+        throw new AxiosError('Invalid URL: missing "//" after protocol', AxiosError.ERR_INVALID_URL, config);
+      }
+    }
+    function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls, config) {
+      assertValidHttpProtocolURL(requestedURL, config);
       let isRelativeUrl = !isAbsoluteURL(requestedURL);
       if (baseURL && (isRelativeUrl || allowAbsoluteUrls === false)) {
+        assertValidHttpProtocolURL(baseURL, config);
         return combineURLs(baseURL, requestedURL);
       }
       return requestedURL;
@@ -62020,7 +62121,7 @@ var require_axios = __commonJS({
     function getEnv(key) {
       return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || "";
     }
-    var VERSION = "1.17.0";
+    var VERSION = "1.18.1";
     function parseProtocol(url2) {
       const match = /^([-+\w]{1,25}):(?:\/\/)?/.exec(url2);
       return match && match[1] || "";
@@ -62042,13 +62143,13 @@ var require_axios = __commonJS({
         const params = match[2];
         const encoding = match[3] ? "base64" : "utf8";
         const body = match[4];
-        let mime;
+        let mime = "";
         if (type) {
           mime = params ? type + params : type;
         } else if (params) {
           mime = "text/plain" + params;
         }
-        const buffer = Buffer.from(decodeURIComponent(body), encoding);
+        const buffer = encoding === "base64" ? Buffer.from(body, "base64") : Buffer.from(decodeURIComponent(body), encoding);
         if (asBlob) {
           if (!_Blob) {
             throw new AxiosError("Blob is not supported", AxiosError.ERR_NOT_SUPPORT);
@@ -62372,13 +62473,29 @@ var require_axios = __commonJS({
         }, cb);
       } : fn;
     };
-    var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set(["localhost"]);
+    var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "0.0.0.0"]);
     var isIPv4Loopback = (host) => {
       const parts = host.split(".");
       if (parts.length !== 4) return false;
       if (parts[0] !== "127") return false;
       return parts.every((p) => /^\d+$/.test(p) && Number(p) >= 0 && Number(p) <= 255);
     };
+    var isIPv6ZeroGroup = (group) => /^0{1,4}$/.test(group);
+    var isIPv6Unspecified = (host) => {
+      if (host === "::") return true;
+      const compressionIndex = host.indexOf("::");
+      if (compressionIndex !== -1) {
+        if (compressionIndex !== host.lastIndexOf("::")) return false;
+        const left = host.slice(0, compressionIndex);
+        const right = host.slice(compressionIndex + 2);
+        const leftGroups = left ? left.split(":") : [];
+        const rightGroups = right ? right.split(":") : [];
+        const explicitGroups = leftGroups.length + rightGroups.length;
+        return explicitGroups < 8 && leftGroups.every(isIPv6ZeroGroup) && rightGroups.every(isIPv6ZeroGroup);
+      }
+      const groups = host.split(":");
+      return groups.length === 8 && groups.every(isIPv6ZeroGroup);
+    };
     var isIPv6Loopback = (host) => {
       if (host === "::1") return true;
       const v4MappedDotted = host.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/i);
@@ -62401,6 +62518,7 @@ var require_axios = __commonJS({
       if (!host) return false;
       if (LOOPBACK_HOSTNAMES.has(host)) return true;
       if (isIPv4Loopback(host)) return true;
+      if (isIPv6Unspecified(host)) return true;
       return isIPv6Loopback(host);
     };
     var DEFAULT_PORTS = {
@@ -62593,6 +62711,8 @@ var require_axios = __commonJS({
       }), throttled[1]];
     };
     var asyncDecorator = (fn) => (...args) => utils$1.asap(() => fn(...args));
+    var isHexDigit = (charCode) => charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 70 || charCode >= 97 && charCode <= 102;
+    var isPercentEncodedByte = (str, i, len) => i + 2 < len && isHexDigit(str.charCodeAt(i + 1)) && isHexDigit(str.charCodeAt(i + 2));
     function estimateDataURLDecodedBytes(url2) {
       if (!url2 || typeof url2 !== "string") return 0;
       if (!url2.startsWith("data:")) return 0;
@@ -62608,7 +62728,7 @@ var require_axios = __commonJS({
           if (body.charCodeAt(i) === 37 && i + 2 < len) {
             const a = body.charCodeAt(i + 1);
             const b = body.charCodeAt(i + 2);
-            const isHex = (a >= 48 && a <= 57 || a >= 65 && a <= 70 || a >= 97 && a <= 102) && (b >= 48 && b <= 57 || b >= 65 && b <= 70 || b >= 97 && b <= 102);
+            const isHex = isHexDigit(a) && isHexDigit(b);
             if (isHex) {
               effectiveLen -= 2;
               i += 2;
@@ -62640,13 +62760,13 @@ var require_axios = __commonJS({
         const bytes2 = groups * 3 - (pad || 0);
         return bytes2 > 0 ? bytes2 : 0;
       }
-      if (typeof Buffer !== "undefined" && typeof Buffer.byteLength === "function") {
-        return Buffer.byteLength(body, "utf8");
-      }
       let bytes = 0;
       for (let i = 0, len = body.length; i < len; i++) {
         const c = body.charCodeAt(i);
-        if (c < 128) {
+        if (c === 37 && isPercentEncodedByte(body, i, len)) {
+          bytes += 1;
+          i += 2;
+        } else if (c < 128) {
           bytes += 1;
         } else if (c < 2048) {
           bytes += 2;
@@ -62702,6 +62822,33 @@ var require_axios = __commonJS({
     var kAxiosInstalledTunnel = /* @__PURE__ */ Symbol("axios.http.installedTunnel");
     var tunnelingAgentCache = /* @__PURE__ */ new Map();
     var tunnelingAgentCacheUser = /* @__PURE__ */ new WeakMap();
+    var NODE_NATIVE_ENV_PROXY_SUPPORT = {
+      22: 21,
+      24: 5
+    };
+    function isNodeNativeEnvProxySupported(nodeVersion = process.versions && process.versions.node) {
+      if (!nodeVersion) {
+        return false;
+      }
+      const [major, minor] = nodeVersion.split(".").map((part) => Number(part));
+      if (!Number.isInteger(major) || !Number.isInteger(minor)) {
+        return false;
+      }
+      if (major > 24) {
+        return true;
+      }
+      return NODE_NATIVE_ENV_PROXY_SUPPORT[major] != null && minor >= NODE_NATIVE_ENV_PROXY_SUPPORT[major];
+    }
+    function isNodeEnvProxyEnabled(agent, nodeVersion = process.versions && process.versions.node) {
+      if (!isNodeNativeEnvProxySupported(nodeVersion)) {
+        return false;
+      }
+      const agentOptions = agent && agent.options;
+      return Boolean(agentOptions && utils$1.hasOwnProp(agentOptions, "proxyEnv") && agentOptions.proxyEnv != null);
+    }
+    function getProxyEnvAgent(options, configHttpAgent, configHttpsAgent) {
+      return isHttps.test(options.protocol) ? configHttpsAgent || https.globalAgent : configHttpAgent || http.globalAgent;
+    }
     function getTunnelingAgent(agentOptions, userHttpsAgent) {
       const key = agentOptions.protocol + "//" + agentOptions.hostname + ":" + (agentOptions.port || "") + "#" + (agentOptions.auth || "");
       const cache = userHttpsAgent ? tunnelingAgentCacheUser.get(userHttpsAgent) || tunnelingAgentCacheUser.set(userHttpsAgent, /* @__PURE__ */ new Map()).get(userHttpsAgent) : tunnelingAgentCache;
@@ -62753,13 +62900,37 @@ var require_axios = __commonJS({
       if (options.beforeRedirects.auth) {
         options.beforeRedirects.auth(options);
       }
+      if (options.beforeRedirects.sensitiveHeaders) {
+        options.beforeRedirects.sensitiveHeaders(options, requestDetails);
+      }
       if (options.beforeRedirects.config) {
         options.beforeRedirects.config(options, responseDetails, requestDetails);
       }
     }
-    function setProxy(options, configProxy, location2, isRedirect, configHttpsAgent) {
+    function stripMatchingHeaders(headers, sensitiveSet) {
+      if (!headers) {
+        return;
+      }
+      Object.keys(headers).forEach((header) => {
+        if (sensitiveSet.has(header.toLowerCase())) {
+          delete headers[header];
+        }
+      });
+    }
+    function isSameOriginRedirect(redirectOptions, requestDetails) {
+      if (!requestDetails) {
+        return false;
+      }
+      try {
+        return new URL(requestDetails.url).origin === new URL(redirectOptions.href).origin;
+      } catch (e) {
+        return false;
+      }
+    }
+    function setProxy(options, configProxy, location2, isRedirect, configHttpsAgent, configHttpAgent) {
       let proxy = configProxy;
-      if (!proxy && proxy !== false) {
+      const proxyEnvAgent = getProxyEnvAgent(options, configHttpAgent, configHttpsAgent);
+      if (!proxy && proxy !== false && !isNodeEnvProxyEnabled(proxyEnvAgent)) {
         const proxyUrl = getProxyForUrl(location2);
         if (proxyUrl) {
           if (!shouldBypassProxy(location2)) {
@@ -62850,7 +63021,7 @@ var require_axios = __commonJS({
         }
       }
       options.beforeRedirects.proxy = function beforeRedirect(redirectOptions) {
-        setProxy(redirectOptions, configProxy, redirectOptions.href, true, configHttpsAgent);
+        setProxy(redirectOptions, configProxy, redirectOptions.href, true, configHttpsAgent, configHttpAgent);
       };
     }
     var isHttpAdapterSupported = typeof process !== "undefined" && utils$1.kindOf(process) === "process";
@@ -62927,7 +63098,7 @@ var require_axios = __commonJS({
     };
     var httpAdapter = isHttpAdapterSupported && function httpAdapter2(config) {
       return wrapAsync(async function dispatchHttpRequest(resolve, reject, onDone) {
-        const own2 = (key) => utils$1.hasOwnProp(config, key) ? config[key] : void 0;
+        const own2 = (key) => utils$1.getSafeProp(config, key);
         const transitional = own2("transitional") || transitionalDefaults;
         let data = own2("data");
         let lookup = own2("lookup");
@@ -62935,9 +63106,17 @@ var require_axios = __commonJS({
         let httpVersion = own2("httpVersion");
         if (httpVersion === void 0) httpVersion = 1;
         let http2Options = own2("http2Options");
+        const httpAgent = own2("httpAgent");
+        const httpsAgent = own2("httpsAgent");
+        const configProxy = own2("proxy");
         const responseType = own2("responseType");
         const responseEncoding = own2("responseEncoding");
-        const method = config.method.toUpperCase();
+        const socketPath = own2("socketPath");
+        const method = own2("method").toUpperCase();
+        const maxRedirects = own2("maxRedirects");
+        const maxBodyLength = own2("maxBodyLength");
+        const maxContentLength = own2("maxContentLength");
+        const decompress = own2("decompress");
         let isDone;
         let rejected = false;
         let req;
@@ -62976,9 +63155,11 @@ var require_axios = __commonJS({
           }
         }
         function createTimeoutError() {
-          let timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
-          if (config.timeoutErrorMessage) {
-            timeoutErrorMessage = config.timeoutErrorMessage;
+          const configTimeout = own2("timeout");
+          let timeoutErrorMessage = configTimeout ? "timeout of " + configTimeout + "ms exceeded" : "timeout exceeded";
+          const configTimeoutErrorMessage = own2("timeoutErrorMessage");
+          if (configTimeoutErrorMessage) {
+            timeoutErrorMessage = configTimeoutErrorMessage;
           }
           return new AxiosError(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED, config, req);
         }
@@ -63019,15 +63200,16 @@ var require_axios = __commonJS({
             onFinished();
           }
         });
-        const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
-        const parsed = new URL(fullPath, platform.hasBrowserEnv ? platform.origin : void 0);
+        const fullPath = buildFullPath(own2("baseURL"), own2("url"), own2("allowAbsoluteUrls"), config);
+        const urlBase = socketPath ? "http://localhost" : platform.hasBrowserEnv ? platform.origin : void 0;
+        const parsed = new URL(fullPath, urlBase);
         const protocol = parsed.protocol || supportedProtocols[0];
         if (protocol === "data:") {
-          if (config.maxContentLength > -1) {
-            const dataUrl = String(config.url || fullPath || "");
+          if (maxContentLength > -1) {
+            const dataUrl = String(own2("url") || fullPath || "");
             const estimated = estimateDataURLDecodedBytes(dataUrl);
-            if (estimated > config.maxContentLength) {
-              return reject(new AxiosError("maxContentLength size of " + config.maxContentLength + " exceeded", AxiosError.ERR_BAD_RESPONSE, config));
+            if (estimated > maxContentLength) {
+              return reject(new AxiosError("maxContentLength size of " + maxContentLength + " exceeded", AxiosError.ERR_BAD_RESPONSE, config));
             }
           }
           let convertedData;
@@ -63040,7 +63222,7 @@ var require_axios = __commonJS({
             });
           }
           try {
-            convertedData = fromDataURI(config.url, responseType === "blob", {
+            convertedData = fromDataURI(own2("url"), responseType === "blob", {
               Blob: config.env && config.env.Blob
             });
           } catch (err) {
@@ -63105,7 +63287,7 @@ var require_axios = __commonJS({
             return reject(new AxiosError("Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream", AxiosError.ERR_BAD_REQUEST, config));
           }
           headers.setContentLength(data.length, false);
-          if (config.maxBodyLength > -1 && data.length > config.maxBodyLength) {
+          if (maxBodyLength > -1 && data.length > maxBodyLength) {
             return reject(new AxiosError("Request body larger than maxBodyLength limit", AxiosError.ERR_BAD_REQUEST, config));
           }
         }
@@ -63130,8 +63312,8 @@ var require_axios = __commonJS({
         let auth = void 0;
         const configAuth = own2("auth");
         if (configAuth) {
-          const username = configAuth.username || "";
-          const password = configAuth.password || "";
+          const username = utils$1.getSafeProp(configAuth, "username") || "";
+          const password = utils$1.getSafeProp(configAuth, "password") || "";
           auth = username + ":" + password;
         }
         if (!auth && (parsed.username || parsed.password)) {
@@ -63142,13 +63324,12 @@ var require_axios = __commonJS({
         auth && headers.delete("authorization");
         let path$1;
         try {
-          path$1 = buildURL(parsed.pathname + parsed.search, config.params, config.paramsSerializer).replace(/^\?/, "");
+          path$1 = buildURL(parsed.pathname + parsed.search, own2("params"), own2("paramsSerializer")).replace(/^\?/, "");
         } catch (err) {
-          const customErr = new Error(err.message);
-          customErr.config = config;
-          customErr.url = config.url;
-          customErr.exists = true;
-          return reject(customErr);
+          return reject(AxiosError.from(err, AxiosError.ERR_BAD_REQUEST, config, null, null, {
+            url: own2("url"),
+            exists: true
+          }));
         }
         headers.set("Accept-Encoding", utils$1.hasOwnProp(transitional, "advertiseZstdAcceptEncoding") && transitional.advertiseZstdAcceptEncoding === true ? ACCEPT_ENCODING_WITH_ZSTD : ACCEPT_ENCODING, false);
         const options = Object.assign(/* @__PURE__ */ Object.create(null), {
@@ -63156,8 +63337,8 @@ var require_axios = __commonJS({
           method,
           headers: toByteStringHeaderObject(headers),
           agents: {
-            http: config.httpAgent,
-            https: config.httpsAgent
+            http: httpAgent,
+            https: httpsAgent
           },
           auth,
           protocol,
@@ -63167,7 +63348,6 @@ var require_axios = __commonJS({
           http2Options
         });
         !utils$1.isUndefined(lookup) && (options.lookup = lookup);
-        const socketPath = own2("socketPath");
         if (socketPath) {
           if (typeof socketPath !== "string") {
             return reject(new AxiosError("socketPath must be a string", AxiosError.ERR_BAD_OPTION_VALUE, config));
@@ -63185,13 +63365,14 @@ var require_axios = __commonJS({
         } else {
           options.hostname = parsed.hostname.startsWith("[") ? parsed.hostname.slice(1, -1) : parsed.hostname;
           options.port = parsed.port;
-          setProxy(options, config.proxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path, false, config.httpsAgent);
+          setProxy(options, configProxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path, false, httpsAgent, httpAgent);
         }
         let transport;
         let isNativeTransport = false;
+        let transportEnforcesMaxBodyLength = false;
         const isHttpsRequest = isHttps.test(options.protocol);
         if (options.agent == null) {
-          options.agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
+          options.agent = isHttpsRequest ? httpsAgent : httpAgent;
         }
         if (isHttp2) {
           transport = http2Transport;
@@ -63199,12 +63380,14 @@ var require_axios = __commonJS({
           const configTransport = own2("transport");
           if (configTransport) {
             transport = configTransport;
-          } else if (config.maxRedirects === 0) {
+          } else if (maxRedirects === 0) {
             transport = isHttpsRequest ? https : http;
             isNativeTransport = true;
           } else {
-            if (config.maxRedirects) {
-              options.maxRedirects = config.maxRedirects;
+            transportEnforcesMaxBodyLength = true;
+            options.sensitiveHeaders = [];
+            if (maxRedirects) {
+              options.maxRedirects = maxRedirects;
             }
             const configBeforeRedirect = own2("beforeRedirect");
             if (configBeforeRedirect) {
@@ -63222,11 +63405,32 @@ var require_axios = __commonJS({
                 }
               };
             }
+            const sensitiveHeaders = own2("sensitiveHeaders");
+            if (sensitiveHeaders != null) {
+              if (!utils$1.isArray(sensitiveHeaders)) {
+                return reject(new AxiosError("sensitiveHeaders must be an array of strings", AxiosError.ERR_BAD_OPTION_VALUE, config));
+              }
+              const sensitiveSet = /* @__PURE__ */ new Set();
+              for (const header of sensitiveHeaders) {
+                if (!utils$1.isString(header)) {
+                  return reject(new AxiosError("sensitiveHeaders must be an array of strings", AxiosError.ERR_BAD_OPTION_VALUE, config));
+                }
+                sensitiveSet.add(header.toLowerCase());
+              }
+              if (sensitiveSet.size) {
+                options.sensitiveHeaders = Array.from(sensitiveSet);
+                options.beforeRedirects.sensitiveHeaders = function beforeRedirectSensitiveHeaders(redirectOptions, requestDetails) {
+                  if (!isSameOriginRedirect(redirectOptions, requestDetails)) {
+                    stripMatchingHeaders(redirectOptions.headers, sensitiveSet);
+                  }
+                };
+              }
+            }
             transport = isHttpsRequest ? httpsFollow : httpFollow;
           }
         }
-        if (config.maxBodyLength > -1) {
-          options.maxBodyLength = config.maxBodyLength;
+        if (maxBodyLength > -1) {
+          options.maxBodyLength = maxBodyLength;
         } else {
           options.maxBodyLength = Infinity;
         }
@@ -63245,7 +63449,7 @@ var require_axios = __commonJS({
           }
           let responseStream = res;
           const lastRequest = res.req || req;
-          if (config.decompress !== false && res.headers["content-encoding"]) {
+          if (decompress !== false && res.headers["content-encoding"]) {
             if (method === "HEAD" || res.statusCode === 204) {
               delete res.headers["content-encoding"];
             }
@@ -63286,8 +63490,8 @@ var require_axios = __commonJS({
             request: lastRequest
           };
           if (responseType === "stream") {
-            if (config.maxContentLength > -1) {
-              const limit = config.maxContentLength;
+            if (maxContentLength > -1) {
+              const limit = maxContentLength;
               const source = responseStream;
               async function* enforceMaxContentLength() {
                 let totalResponseBytes = 0;
@@ -63311,10 +63515,10 @@ var require_axios = __commonJS({
             responseStream.on("data", function handleStreamData(chunk) {
               responseBuffer.push(chunk);
               totalResponseBytes += chunk.length;
-              if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
+              if (maxContentLength > -1 && totalResponseBytes > maxContentLength) {
                 rejected = true;
                 responseStream.destroy();
-                abort(new AxiosError("maxContentLength size of " + config.maxContentLength + " exceeded", AxiosError.ERR_BAD_RESPONSE, config, lastRequest));
+                abort(new AxiosError("maxContentLength size of " + maxContentLength + " exceeded", AxiosError.ERR_BAD_RESPONSE, config, lastRequest));
               }
             });
             responseStream.on("aborted", function handlerStreamAborted() {
@@ -63364,7 +63568,9 @@ var require_axios = __commonJS({
         });
         const boundSockets = /* @__PURE__ */ new Set();
         req.on("socket", function handleRequestSocket(socket) {
-          socket.setKeepAlive(true, 1e3 * 60);
+          if (typeof socket.setKeepAlive === "function") {
+            socket.setKeepAlive(true, 1e3 * 60);
+          }
           if (!socket[kAxiosSocketListener]) {
             socket.on("error", function handleSocketError(err) {
               const current = socket[kAxiosCurrentReq];
@@ -63386,8 +63592,8 @@ var require_axios = __commonJS({
           }
           boundSockets.clear();
         });
-        if (config.timeout) {
-          const timeout = parseInt(config.timeout, 10);
+        if (own2("timeout")) {
+          const timeout = parseInt(own2("timeout"), 10);
           if (Number.isNaN(timeout)) {
             abort(new AxiosError("error trying to parse `config.timeout` to int", AxiosError.ERR_BAD_OPTION_VALUE, config, req));
             return;
@@ -63419,8 +63625,8 @@ var require_axios = __commonJS({
             }
           });
           let uploadStream = data;
-          if (config.maxBodyLength > -1 && config.maxRedirects === 0) {
-            const limit = config.maxBodyLength;
+          if (maxBodyLength > -1 && !transportEnforcesMaxBodyLength) {
+            const limit = maxBodyLength;
             let bytesSent = 0;
             uploadStream = stream.pipeline([data, new stream.Transform({
               transform(chunk, _enc, cb) {
@@ -63476,7 +63682,11 @@ var require_axios = __commonJS({
             const cookie = cookies2[i].replace(/^\s+/, "");
             const eq = cookie.indexOf("=");
             if (eq !== -1 && cookie.slice(0, eq) === name) {
-              return decodeURIComponent(cookie.slice(eq + 1));
+              try {
+                return decodeURIComponent(cookie.slice(eq + 1));
+              } catch (e) {
+                return cookie.slice(eq + 1);
+              }
             }
           }
           return null;
@@ -63501,6 +63711,7 @@ var require_axios = __commonJS({
       ...thing
     } : thing;
     function mergeConfig(config1, config2) {
+      config1 = config1 || {};
       config2 = config2 || {};
       const config = /* @__PURE__ */ Object.create(null);
       Object.defineProperty(config, "hasOwnProperty", {
@@ -63543,6 +63754,23 @@ var require_axios = __commonJS({
           return getMergedValue(void 0, a);
         }
       }
+      function getMergedTransitionalOption(prop) {
+        const transitional2 = utils$1.hasOwnProp(config2, "transitional") ? config2.transitional : void 0;
+        if (!utils$1.isUndefined(transitional2)) {
+          if (utils$1.isPlainObject(transitional2)) {
+            if (utils$1.hasOwnProp(transitional2, prop)) {
+              return transitional2[prop];
+            }
+          } else {
+            return void 0;
+          }
+        }
+        const transitional1 = utils$1.hasOwnProp(config1, "transitional") ? config1.transitional : void 0;
+        if (utils$1.isPlainObject(transitional1) && utils$1.hasOwnProp(transitional1, prop)) {
+          return transitional1[prop];
+        }
+        return void 0;
+      }
       function mergeDirectKeys(a, b, prop) {
         if (utils$1.hasOwnProp(config2, prop)) {
           return getMergedValue(a, b);
@@ -63593,6 +63821,13 @@ var require_axios = __commonJS({
         const configValue = merge2(a, b, prop);
         utils$1.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
       });
+      if (utils$1.hasOwnProp(config2, "validateStatus") && utils$1.isUndefined(config2.validateStatus) && getMergedTransitionalOption("validateStatusUndefinedResolves") === false) {
+        if (utils$1.hasOwnProp(config1, "validateStatus")) {
+          config.validateStatus = getMergedValue(void 0, config1.validateStatus);
+        } else {
+          delete config.validateStatus;
+        }
+      }
       return config;
     }
     var FORM_DATA_CONTENT_HEADERS = ["content-type", "content-length"];
@@ -63601,7 +63836,7 @@ var require_axios = __commonJS({
         headers.set(formHeaders);
         return;
       }
-      Object.entries(formHeaders).forEach(([key, val]) => {
+      Object.entries(formHeaders || {}).forEach(([key, val]) => {
         if (FORM_DATA_CONTENT_HEADERS.includes(key.toLowerCase())) {
           headers.set(key, val);
         }
@@ -63621,9 +63856,15 @@ var require_axios = __commonJS({
       const allowAbsoluteUrls = own2("allowAbsoluteUrls");
       const url2 = own2("url");
       newConfig.headers = headers = AxiosHeaders.from(headers);
-      newConfig.url = buildURL(buildFullPath(baseURL, url2, allowAbsoluteUrls), own2("params"), own2("paramsSerializer"));
+      newConfig.url = buildURL(buildFullPath(baseURL, url2, allowAbsoluteUrls, newConfig), own2("params"), own2("paramsSerializer"));
       if (auth) {
-        headers.set("Authorization", "Basic " + btoa((auth.username || "") + ":" + (auth.password ? encodeUTF8$1(auth.password) : "")));
+        const username = utils$1.getSafeProp(auth, "username") || "";
+        const password = utils$1.getSafeProp(auth, "password") || "";
+        try {
+          headers.set("Authorization", "Basic " + btoa(username + ":" + (password ? encodeUTF8$1(password) : "")));
+        } catch (e) {
+          throw AxiosError.from(e, AxiosError.ERR_BAD_OPTION_VALUE, config);
+        }
       }
       if (utils$1.isFormData(data)) {
         if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv || utils$1.isReactNative(data)) {
@@ -63770,6 +64011,7 @@ var require_axios = __commonJS({
         const protocol = parseProtocol(_config.url);
         if (protocol && !platform.protocols.includes(protocol)) {
           reject(new AxiosError("Unsupported protocol " + protocol + ":", AxiosError.ERR_BAD_REQUEST, config));
+          done();
           return;
         }
         request.send(requestData || null);
@@ -63805,7 +64047,9 @@ var require_axios = __commonJS({
         });
         signals = null;
       };
-      signals.forEach((signal2) => signal2.addEventListener("abort", onabort));
+      signals.forEach((signal2) => signal2.addEventListener("abort", onabort, {
+        once: true
+      }));
       const {
         signal
       } = controller;
@@ -64035,12 +64279,14 @@ var require_axios = __commonJS({
           composedSignal.unsubscribe();
         });
         let requestContentLength;
+        let pendingBodyError = null;
+        const maxBodyLengthError = () => new AxiosError("Request body larger than maxBodyLength limit", AxiosError.ERR_BAD_REQUEST, config, request);
         try {
           let auth = void 0;
           const configAuth = own2("auth");
           if (configAuth) {
-            const username = configAuth.username || "";
-            const password = configAuth.password || "";
+            const username = utils$1.getSafeProp(configAuth, "username") || "";
+            const password = utils$1.getSafeProp(configAuth, "password") || "";
             auth = {
               username,
               password
@@ -64073,25 +64319,42 @@ var require_axios = __commonJS({
             }
           }
           if (hasMaxBodyLength && method !== "get" && method !== "head") {
-            const outboundLength = await resolveBodyLength(headers, data);
-            if (typeof outboundLength === "number" && isFinite(outboundLength) && outboundLength > maxBodyLength) {
-              throw new AxiosError("Request body larger than maxBodyLength limit", AxiosError.ERR_BAD_REQUEST, config, request);
+            const outboundLength = await getBodyLength(data);
+            if (typeof outboundLength === "number" && isFinite(outboundLength)) {
+              requestContentLength = outboundLength;
+              if (outboundLength > maxBodyLength) {
+                throw maxBodyLengthError();
+              }
             }
           }
-          if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
-            let _request = new Request(url2, {
-              method: "POST",
-              body: data,
-              duplex: "half"
-            });
-            let contentTypeHeader;
-            if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
-              headers.setContentType(contentTypeHeader);
-            }
-            if (_request.body) {
-              const [onProgress, flush] = progressEventDecorator(requestContentLength, progressEventReducer(asyncDecorator(onUploadProgress)));
-              data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+          const mustEnforceStreamBody = hasMaxBodyLength && (utils$1.isReadableStream(data) || utils$1.isStream(data));
+          const trackRequestStream = (stream2, onProgress, flush) => trackStream(stream2, DEFAULT_CHUNK_SIZE, (loadedBytes) => {
+            if (hasMaxBodyLength && loadedBytes > maxBodyLength) {
+              throw pendingBodyError = maxBodyLengthError();
+            }
+            onProgress && onProgress(loadedBytes);
+          }, flush);
+          if (supportsRequestStream && method !== "get" && method !== "head" && (onUploadProgress || mustEnforceStreamBody)) {
+            requestContentLength = requestContentLength == null ? await resolveBodyLength(headers, data) : requestContentLength;
+            if (requestContentLength !== 0 || mustEnforceStreamBody) {
+              let _request = new Request(url2, {
+                method: "POST",
+                body: data,
+                duplex: "half"
+              });
+              let contentTypeHeader;
+              if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) {
+                headers.setContentType(contentTypeHeader);
+              }
+              if (_request.body) {
+                const [onProgress, flush] = onUploadProgress && progressEventDecorator(requestContentLength, progressEventReducer(asyncDecorator(onUploadProgress))) || [];
+                data = trackRequestStream(_request.body, onProgress, flush);
+              }
             }
+          } else if (mustEnforceStreamBody && !isRequestSupported && isReadableStreamSupported && method !== "get" && method !== "head") {
+            data = trackRequestStream(data);
+          } else if (mustEnforceStreamBody && isRequestSupported && !supportsRequestStream && method !== "get" && method !== "head") {
+            throw new AxiosError("Stream request bodies are not supported by the current fetch implementation", AxiosError.ERR_NOT_SUPPORT, config, request);
           }
           if (!utils$1.isString(withCredentials)) {
             withCredentials = withCredentials ? "include" : "omit";
@@ -64115,8 +64378,9 @@ var require_axios = __commonJS({
           };
           request = isRequestSupported && new Request(url2, resolvedOptions);
           let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url2, resolvedOptions));
+          const responseHeaders = AxiosHeaders.from(response.headers);
           if (hasMaxContentLength) {
-            const declaredLength = utils$1.toFiniteNumber(response.headers.get("content-length"));
+            const declaredLength = utils$1.toFiniteNumber(responseHeaders.getContentLength());
             if (declaredLength != null && declaredLength > maxContentLength) {
               throw new AxiosError("maxContentLength size of " + maxContentLength + " exceeded", AxiosError.ERR_BAD_RESPONSE, config, request);
             }
@@ -64127,7 +64391,7 @@ var require_axios = __commonJS({
             ["status", "statusText", "headers"].forEach((prop) => {
               options[prop] = response[prop];
             });
-            const responseContentLength = utils$1.toFiniteNumber(response.headers.get("content-length"));
+            const responseContentLength = utils$1.toFiniteNumber(responseHeaders.getContentLength());
             const [onProgress, flush] = onDownloadProgress && progressEventDecorator(responseContentLength, progressEventReducer(asyncDecorator(onDownloadProgress), true)) || [];
             let bytesRead = 0;
             const onChunkProgress = (loadedBytes) => {
@@ -64178,13 +64442,35 @@ var require_axios = __commonJS({
             const canceledError = composedSignal.reason;
             canceledError.config = config;
             request && (canceledError.request = request);
-            err !== canceledError && (canceledError.cause = err);
+            if (err !== canceledError) {
+              Object.defineProperty(canceledError, "cause", {
+                __proto__: null,
+                value: err,
+                writable: true,
+                enumerable: false,
+                configurable: true
+              });
+            }
             throw canceledError;
           }
+          if (pendingBodyError) {
+            request && !pendingBodyError.request && (pendingBodyError.request = request);
+            throw pendingBodyError;
+          }
+          if (err instanceof AxiosError) {
+            request && !err.request && (err.request = request);
+            throw err;
+          }
           if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) {
-            throw Object.assign(new AxiosError("Network Error", AxiosError.ERR_NETWORK, config, request, err && err.response), {
-              cause: err.cause || err
+            const networkError = new AxiosError("Network Error", AxiosError.ERR_NETWORK, config, request, err && err.response);
+            Object.defineProperty(networkError, "cause", {
+              __proto__: null,
+              value: err.cause || err,
+              writable: true,
+              enumerable: false,
+              configurable: true
             });
+            throw networkError;
           }
           throw AxiosError.from(err, err && err.code, config, request, err && err.response);
         }
@@ -64259,7 +64545,7 @@ var require_axios = __commonJS({
       if (!adapter) {
         const reasons = Object.entries(rejectedReasons).map(([id, state]) => `adapter ${id} ` + (state === false ? "is not supported by the environment" : "is not available in the build"));
         let s = length ? reasons.length > 1 ? "since :\n" + reasons.map(renderReason).join("\n") : " " + renderReason(reasons[0]) : "as no adapter specified";
-        throw new AxiosError(`There is no suitable adapter to dispatch the request ` + s, "ERR_NOT_SUPPORT");
+        throw new AxiosError(`There is no suitable adapter to dispatch the request ` + s, AxiosError.ERR_NOT_SUPPORT);
       }
       return adapter;
     }
@@ -64346,7 +64632,7 @@ var require_axios = __commonJS({
       };
     };
     function assertOptions(options, schema, allowUnknown) {
-      if (typeof options !== "object") {
+      if (typeof options !== "object" || options === null) {
         throw new AxiosError("options must be an object", AxiosError.ERR_BAD_OPTION_VALUE);
       }
       const keys = Object.keys(options);
@@ -64438,7 +64724,8 @@ var require_axios = __commonJS({
             forcedJSONParsing: validators.transitional(validators.boolean),
             clarifyTimeoutError: validators.transitional(validators.boolean),
             legacyInterceptorReqResOrdering: validators.transitional(validators.boolean),
-            advertiseZstdAcceptEncoding: validators.transitional(validators.boolean)
+            advertiseZstdAcceptEncoding: validators.transitional(validators.boolean),
+            validateStatusUndefinedResolves: validators.transitional(validators.boolean)
           }, false);
         }
         if (paramsSerializer != null) {
@@ -64528,7 +64815,7 @@ var require_axios = __commonJS({
       }
       getUri(config) {
         config = mergeConfig(this.defaults, config);
-        const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
+        const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls, config);
         return buildURL(fullPath, config.params, config.paramsSerializer);
       }
     };
@@ -64537,7 +64824,7 @@ var require_axios = __commonJS({
         return this.request(mergeConfig(config || {}, {
           method,
           url: url2,
-          data: (config || {}).data
+          data: config && utils$1.hasOwnProp(config, "data") ? config.data : void 0
         }));
       };
     });
@@ -65119,6 +65406,3267 @@ var require_diff = __commonJS({
   }
 });
 
+// ../../node_modules/@coderifts/sdk/dist/cjs/errors.js
+var require_errors5 = __commonJS({
+  "../../node_modules/@coderifts/sdk/dist/cjs/errors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.AuthError = exports2.RateLimitError = exports2.TimeoutError = exports2.ApiError = exports2.CodeRiftsError = void 0;
+    var CodeRiftsError = class extends Error {
+      code;
+      constructor(message, code = "unknown") {
+        super(message);
+        this.name = "CodeRiftsError";
+        this.code = code;
+      }
+    };
+    exports2.CodeRiftsError = CodeRiftsError;
+    var ApiError = class extends CodeRiftsError {
+      status;
+      code;
+      body;
+      constructor(status, body) {
+        super(`[${status}] ${body.error}: ${body.message}`);
+        this.name = "ApiError";
+        this.status = status;
+        this.code = body.error;
+        this.body = body;
+      }
+    };
+    exports2.ApiError = ApiError;
+    var TimeoutError = class extends CodeRiftsError {
+      constructor(timeoutMs) {
+        super(`Request timed out after ${timeoutMs}ms`);
+        this.name = "TimeoutError";
+      }
+    };
+    exports2.TimeoutError = TimeoutError;
+    var RateLimitError = class extends ApiError {
+      constructor(body) {
+        super(429, body);
+        this.name = "RateLimitError";
+      }
+    };
+    exports2.RateLimitError = RateLimitError;
+    var AuthError = class extends ApiError {
+      constructor(body) {
+        super(401, body);
+        this.name = "AuthError";
+      }
+    };
+    exports2.AuthError = AuthError;
+  }
+});
+
+// ../../node_modules/@coderifts/sdk/dist/cjs/client.js
+var require_client = __commonJS({
+  "../../node_modules/@coderifts/sdk/dist/cjs/client.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CodeRifts = void 0;
+    var errors_js_1 = require_errors5();
+    var DEFAULT_BASE_URL = "https://app.coderifts.com";
+    var DEFAULT_TIMEOUT = 3e4;
+    var CodeRifts = class {
+      apiKey;
+      baseUrl;
+      timeout;
+      constructor(options) {
+        if (!options.apiKey) {
+          throw new Error("apiKey is required");
+        }
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+        this.timeout = options.timeout || DEFAULT_TIMEOUT;
+      }
+      // ─── Internal HTTP helper ──────────────────────────────────────────────
+      async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const res = await fetch(url, {
+            method,
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${this.apiKey}`
+            },
+            body: body ? JSON.stringify(body) : void 0,
+            signal: controller.signal
+          });
+          const json = await res.json();
+          if (!res.ok) {
+            const errorBody = {
+              error: json.error || "unknown",
+              message: json.message || res.statusText
+            };
+            if (res.status === 401)
+              throw new errors_js_1.AuthError(errorBody);
+            if (res.status === 429)
+              throw new errors_js_1.RateLimitError(errorBody);
+            throw new errors_js_1.ApiError(res.status, errorBody);
+          }
+          return json;
+        } catch (err) {
+          if (err instanceof errors_js_1.ApiError)
+            throw err;
+          if (err.name === "AbortError") {
+            throw new errors_js_1.TimeoutError(this.timeout);
+          }
+          throw err;
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+      // ─── 1. preflightCheck ─────────────────────────────────────────────────
+      /**
+       * Check whether it is safe to proceed with a tool invocation.
+       *
+       * Accepts `old_spec` / `new_spec` (OpenAPI YAML strings) and a `tool_name`.
+       * The SDK converts the specs to MCP tool arrays and calls POST /api/v1/agent/preflight.
+       */
+      async preflightCheck(req) {
+        const raw = await this.request("POST", "/api/v1/agent/preflight", {
+          tool_name: req.tool_name,
+          old_spec: req.old_spec,
+          new_spec: req.new_spec
+        });
+        const decision = raw.decision || "ALLOW";
+        return {
+          decision,
+          omega_api: raw.omega_api ?? 0,
+          safe: decision === "ALLOW" || decision === "WARN",
+          reflex_triggers: raw.reflex_triggers || [],
+          affected_tools: raw.affected_tools || [],
+          confidence_score: raw.confidence_score,
+          reflex_override: raw.reflex_override,
+          omega_components: raw.omega_components,
+          breaking_changes: raw.breaking_changes,
+          stats: raw.stats,
+          mitigation_available: raw.mitigation_available
+        };
+      }
+      // ─── 2. diff ───────────────────────────────────────────────────────────
+      /**
+       * Full analysis of two OpenAPI specs.
+       */
+      async diff(req) {
+        return this.request("POST", "/api/v1/diff", req);
+      }
+      // ─── 3. explainDecision ────────────────────────────────────────────────
+      /**
+       * Returns a human-readable explanation of why a decision was made.
+       *
+       * Computed client-side from the omega components and reflex triggers.
+       */
+      async explainDecision(req) {
+        const components = [];
+        if (req.omega_components) {
+          for (const [name, value] of Object.entries(req.omega_components)) {
+            if (typeof value === "number") {
+              components.push({
+                name,
+                value,
+                description: describeComponent(name, value)
+              });
+            }
+          }
+        }
+        const triggers = req.reflex_triggers || [];
+        let summary = `Decision: ${req.decision} (\u03A9_API = ${req.omega_api}).`;
+        if (triggers.length > 0) {
+          summary += ` ${triggers.length} reflex rule(s) triggered.`;
+        }
+        if (req.decision === "BLOCK") {
+          summary += " This change is blocked due to high risk.";
+        } else if (req.decision === "REQUIRE_APPROVAL") {
+          summary += " This change requires manual approval before merging.";
+        } else if (req.decision === "WARN") {
+          summary += " This change has warnings but can proceed.";
+        } else {
+          summary += " This change is safe to proceed.";
+        }
+        return { summary, components };
+      }
+      // ─── 4. howToUnblock ───────────────────────────────────────────────────
+      /**
+       * Returns actionable steps to resolve a BLOCK decision.
+       *
+       * Computed client-side from breaking changes and detected patterns.
+       */
+      async howToUnblock(req) {
+        const actions = [];
+        let step = 1;
+        if (req.decision !== "BLOCK") {
+          actions.push({
+            step: step++,
+            description: `Current decision is "${req.decision}" \u2014 no unblock needed.`
+          });
+          return { actions };
+        }
+        const bcs = req.breaking_changes || [];
+        if (bcs.length > 0) {
+          actions.push({
+            step: step++,
+            description: `Fix ${bcs.length} breaking change(s) in your spec.`,
+            code_example: bcs.slice(0, 3).map((bc) => `# ${bc.type} at ${bc.path}: ${bc.description}`).join("\n")
+          });
+        }
+        const triggers = req.reflex_triggers || [];
+        for (const trigger of triggers) {
+          actions.push({
+            step: step++,
+            description: `Resolve reflex rule: ${trigger.rule}`
+          });
+        }
+        actions.push({
+          step: step++,
+          description: "Request a manual override via POST /api/v1/ledger/:id/override if this is an emergency."
+        });
+        return { actions };
+      }
+      // ─── 5. scoreMcp ──────────────────────────────────────────────────────
+      /**
+       * Score an MCP manifest for agent safety.
+       */
+      async scoreMcp(req) {
+        return this.request("POST", "/api/v1/agent-readiness-score", {
+          spec: req.manifest,
+          spec_type: "mcp"
+        });
+      }
+      // ─── 6. getLedger ─────────────────────────────────────────────────────
+      /**
+       * Query compliance ledger entries.
+       */
+      async getLedger(req = {}) {
+        const params = new URLSearchParams();
+        if (req.repo)
+          params.set("repo", req.repo);
+        if (req.decision)
+          params.set("decision", req.decision);
+        if (req.from)
+          params.set("from", req.from);
+        if (req.to)
+          params.set("to", req.to);
+        if (req.limit)
+          params.set("limit", String(req.limit));
+        const qs = params.toString();
+        const path = `/api/v1/ledger${qs ? `?${qs}` : ""}`;
+        return this.request("GET", path);
+      }
+      // ─── 7. simulatePolicy ───────────────────────────────────────────────
+      /**
+       * Test a YAML policy against two OpenAPI specs.
+       */
+      async simulatePolicy(req) {
+        return this.request("POST", "/api/v1/policy-simulator", req);
+      }
+      // ─── 8. preflightChangeSet ─────────────────────────────────────────────
+      /**
+       * Preflight a multi-artifact change set (OpenAPI / GraphQL / gRPC / AsyncAPI / MCP manifest)
+       * in one call. Returns one aggregated ALLOW/WARN/REQUIRE_APPROVAL/BLOCK decision (strictest-wins)
+       * with per-artifact findings, a bundle fingerprint, and a decision-result.v1.1 envelope +
+       * chain receipt. POST /api/v1/preflight.
+       */
+      async preflightChangeSet(req) {
+        return this.request("POST", "/api/v1/preflight", req);
+      }
+      // ─── 9. verifyReceipt ──────────────────────────────────────────────────
+      /**
+       * Verify a CodeRifts chain receipt's signature and integrity. No API key is required — this is a
+       * public endpoint (the Authorization header is sent for consistency but ignored server-side).
+       * POST /api/v1/verify-receipt.
+       */
+      async verifyReceipt(token) {
+        return this.request("POST", "/api/v1/verify-receipt", { token });
+      }
+      // ─── 10. getDecisionDetails ────────────────────────────────────────────
+      /**
+       * Look up a stored decision by decision_id or fingerprint; returns the stored
+       * decision-result.v1.1 envelope + meta. POST /api/v1/decisions/lookup.
+       */
+      async getDecisionDetails(req) {
+        return this.request("POST", "/api/v1/decisions/lookup", req);
+      }
+    };
+    exports2.CodeRifts = CodeRifts;
+    function describeComponent(name, value) {
+      const descriptions = {
+        S_contract: "Contract severity score \u2014 measures how severe the breaking changes are",
+        P_break: "Break probability \u2014 likelihood that downstream consumers will break",
+        S_blast_eff: "Blast radius \u2014 how many consumers are affected",
+        S_agent: "Agent safety score \u2014 risk to AI agent tool invocations",
+        S_runtime: "Runtime impact \u2014 risk of runtime failures",
+        ECI: "Ecosystem coupling index \u2014 how tightly coupled the API is",
+        M_eff: "Migration effort \u2014 estimated effort to migrate consumers",
+        D_contract: "Contract distance \u2014 semantic distance between old and new contracts",
+        confidence_score: "Confidence in the analysis result"
+      };
+      return descriptions[name] || `${name} = ${value}`;
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/sdk/dist/cjs/decision.js
+var require_decision = __commonJS({
+  "../../node_modules/@coderifts/sdk/dist/cjs/decision.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.readDecision = readDecision;
+    var EXECUTION_ACTION = {
+      ALLOW: "CONTINUE",
+      WARN: "CONTINUE_WITH_MONITORING",
+      REQUIRE_APPROVAL: "REQUEST_APPROVAL",
+      BLOCK: "STOP"
+    };
+    function isExecutionAction(v) {
+      return v === "CONTINUE" || v === "CONTINUE_WITH_MONITORING" || v === "REQUEST_APPROVAL" || v === "STOP";
+    }
+    function readDecision(response) {
+      if (!response || typeof response !== "object") {
+        return { executionAction: "STOP", decision: null, reason: "UNREADABLE_DECISION" };
+      }
+      const r = response;
+      const env = r.decision_result;
+      if (env && typeof env === "object" && isExecutionAction(env.execution_action)) {
+        const receipt = env.receipt;
+        return {
+          executionAction: env.execution_action,
+          decision: typeof env.decision === "string" ? env.decision : null,
+          envelope: env,
+          receipt: receipt && typeof receipt === "object" ? receipt : void 0
+        };
+      }
+      if (isExecutionAction(r.execution_action)) {
+        return {
+          executionAction: r.execution_action,
+          decision: typeof r.decision === "string" ? r.decision : null
+        };
+      }
+      if (typeof r.decision === "string" && Object.prototype.hasOwnProperty.call(EXECUTION_ACTION, r.decision)) {
+        return { executionAction: EXECUTION_ACTION[r.decision], decision: r.decision };
+      }
+      return {
+        executionAction: "STOP",
+        decision: typeof r.decision === "string" ? r.decision : null,
+        reason: "UNREADABLE_DECISION"
+      };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/sdk/dist/cjs/index.js
+var require_cjs3 = __commonJS({
+  "../../node_modules/@coderifts/sdk/dist/cjs/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.readDecision = exports2.AuthError = exports2.RateLimitError = exports2.TimeoutError = exports2.ApiError = exports2.CodeRiftsError = exports2.CodeRifts = void 0;
+    var client_js_1 = require_client();
+    Object.defineProperty(exports2, "CodeRifts", { enumerable: true, get: function() {
+      return client_js_1.CodeRifts;
+    } });
+    var errors_js_1 = require_errors5();
+    Object.defineProperty(exports2, "CodeRiftsError", { enumerable: true, get: function() {
+      return errors_js_1.CodeRiftsError;
+    } });
+    Object.defineProperty(exports2, "ApiError", { enumerable: true, get: function() {
+      return errors_js_1.ApiError;
+    } });
+    Object.defineProperty(exports2, "TimeoutError", { enumerable: true, get: function() {
+      return errors_js_1.TimeoutError;
+    } });
+    Object.defineProperty(exports2, "RateLimitError", { enumerable: true, get: function() {
+      return errors_js_1.RateLimitError;
+    } });
+    Object.defineProperty(exports2, "AuthError", { enumerable: true, get: function() {
+      return errors_js_1.AuthError;
+    } });
+    var decision_js_1 = require_decision();
+    Object.defineProperty(exports2, "readDecision", { enumerable: true, get: function() {
+      return decision_js_1.readDecision;
+    } });
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/detector.js
+var require_detector = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/detector.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.builtinDetector = exports2.DETECTOR_VERSION = void 0;
+    var node_zlib_1 = require("node:zlib");
+    exports2.DETECTOR_VERSION = "builtin/1.1.0";
+    var CONTRACT_PATH_RE = [
+      /openapi/i,
+      /swagger/i,
+      /asyncapi/i,
+      /\.graphql$/i,
+      /\.gql$/i,
+      /\.proto$/i,
+      /\.pb($|\.)/i,
+      /(^|\/)[\w.-]*mcp[\w.-]*\.json$/i,
+      /tools-catalog\.json$/i,
+      /schema\.prisma$/i,
+      /(^|\/)migrations?\//i,
+      /(^|\/)alembic\//i,
+      /(^|\/)buf\.ya?ml$/i,
+      /\.spectral\.ya?ml$/i,
+      /(^|\/)\.github\/workflows\//i,
+      /(^|\/)\.husky\//i,
+      /api[-_]?contract/i,
+      /service-definition/i,
+      /(^|\/)contracts?\//i,
+      /schemas?\/components?\//i,
+      /\bcontract\.json$/i,
+      /(^|\/)spec\.(ya?ml|json)$/i,
+      /api[-_/]spec\.(ya?ml|json)$/i,
+      /-api\.(ya?ml|yml)$/i,
+      /current-api/i,
+      /(^|\/)(src\/)?generated\//i,
+      /(^|\/)gen\//i,
+      /\.pb\.go$/i,
+      /openapi\.d\.ts$/i
+    ];
+    var NON_SSOT_PATH_RE = [
+      /(^|\/)tests?\//i,
+      /(^|\/)__tests__\//i,
+      /(^|\/)__mocks__\//i,
+      /\/fixtures?\//i,
+      /(^|\/)mocks?\//i,
+      /\.test\.[jt]sx?$/i,
+      /\.spec\.[jt]sx?$/i,
+      /(^|\/)src\/internal\//i,
+      /(^|\/)node_modules\//i
+    ];
+    var PROSE_PATH_RE = [/(^|\/)README(\.\w+)?$/i, /(^|\/)CHANGELOG(\.\w+)?$/i, /(^|\/)LICENSE(\.\w+)?$/i, /\.md$/i];
+    var CODE_CONTRACT_PATH_RE = [/(^|\/)src\/routes?\//i, /(^|\/)routes?\//i, /(^|\/)app\/api\//i, /(^|\/)src\/dto\//i, /dto/i, /routers?\//i, /\.prisma$/i, /\.tf$/i, /server\/routers?\//i];
+    var GATE_PATH_RE = [/(^|\/)\.github\/workflows\//i, /(^|\/)\.husky\//i, /\.spectral\.ya?ml$/i, /(^|\/)buf\.ya?ml$/i];
+    var LOCKFILE_RE = /(package-lock\.json|pnpm-lock\.ya?ml|yarn\.lock|composer\.lock|Cargo\.lock)$/i;
+    var CONTRACT_CONTENT_RE = [
+      /\bopenapi\s*[:=]\s*["']?3/i,
+      /["']openapi["']\s*:/i,
+      /\bswagger\s*[:=]/i,
+      /["']swagger["']\s*:/i,
+      /\basyncapi\s*[:=]/i,
+      /["']asyncapi["']\s*:/i,
+      /(^|\n)\s*paths\s*:/i,
+      /["']paths["']\s*:/i,
+      /syntax\s*=\s*["']proto3/i,
+      /(^|\n)\s*message\s+\w+\s*\{/i,
+      /\btype\s+(Query|Mutation|Subscription)\b/i,
+      /["']tools["']\s*:\s*\[/i,
+      /["']inputSchema["']\s*:/i,
+      /\/v\d+\/[\w{}.-]*\s*:/,
+      // versioned route-path key
+      /\bchannels\s*:/i
+    ];
+    var CONTRACT_STRUCTURE_RE = [
+      /(get|post|put|delete|patch)\s*:\s*\{?/i,
+      /message\s+\w+\s*\{[^}]*=\s*\d+/i,
+      /\/v\d+\/[\w{}.-]*\s*:/,
+      /"name"\s*:\s*"[^"]+"[\s,}]*"?inputSchema/i
+    ];
+    var REAL_CHANGE_RE = [
+      /required\s*:\s*\[/i,
+      /["']required["']\s*:\s*\[/i,
+      /\btype\s*:\s*\w+/i,
+      /nullable\s*:/i,
+      /:\s*\w+!/,
+      /additionalProperties\s*:\s*(true|false)/i,
+      /["']additionalProperties["']/i,
+      /\bDROP\s+COLUMN\b/i,
+      /\bALTER\s+COLUMN\b/i,
+      /alter_column\s*\(/i,
+      /new_column_name/i,
+      /\bRENAME\b/i,
+      /DROP\s+TABLE/i,
+      /@IsString|@IsOptional|response_model|z\.string|@unique/i,
+      /app\.(get|post|put|delete|patch)\s*\(/i,
+      /@router\.(get|post|put|delete|patch)/i,
+      /\/v\d+\//,
+      /continue-on-error|if:\s*false|:\s*off\b|'off'|"off"/i,
+      /\bignore\s*:/i,
+      /(^|\n)\s*breaking\s*:/i
+    ];
+    var INERT_KEY_RE = [
+      /^description\s*:/i,
+      /^["']description["']\s*:/i,
+      /^summary\s*:/i,
+      /^title\s*:/i,
+      /^contact\s*:/i,
+      /^name\s*:/i,
+      /^examples?\s*:/i,
+      /^["']examples?["']\s*:/i,
+      /^x-[\w-]+\s*:/i,
+      /^["']x-[\w-]+["']\s*:/i
+    ];
+    var READ_ONLY_TOOLS = /* @__PURE__ */ new Set(["read", "grep", "glob", "ls", "cat", "view", "search", "list", "get"]);
+    var FORMATTER_RE = /\b(prettier|eslint\s+--fix|gofmt|rustfmt|black|clang-format|dprint)\b/i;
+    var GATE_KEYWORD_RE = /coderifts|agent-guard|contract-check|contract\b|preflight|spectral|\bbuf\b/i;
+    function anyMatch(res, s) {
+      return res.some((r) => r.test(s));
+    }
+    function argString(args) {
+      if (args == null)
+        return "";
+      if (typeof args === "string")
+        return args;
+      try {
+        return JSON.stringify(args);
+      } catch {
+        return "";
+      }
+    }
+    function changeText(call) {
+      const parts = [];
+      if (call.diff)
+        parts.push(call.diff);
+      const a = call.arguments;
+      if (a && typeof a === "object") {
+        for (const k of ["new_string", "old_string", "contents", "content", "patch", "command"]) {
+          const v = a[k];
+          if (typeof v === "string")
+            parts.push(v);
+        }
+        const edits = a.edits;
+        if (Array.isArray(edits))
+          for (const e of edits)
+            parts.push(argString(e));
+      }
+      return parts.join("\n");
+    }
+    function commandText(call) {
+      const a = call.arguments;
+      const c = a && typeof a === "object" ? a.command : void 0;
+      return typeof c === "string" ? c : "";
+    }
+    function allPaths(call) {
+      const out = [...call.filesTouched || []];
+      const a = call.arguments;
+      if (a && typeof a === "object" && typeof a.path === "string")
+        out.push(a.path);
+      return out;
+    }
+    function isContractPath(p) {
+      if (anyMatch(NON_SSOT_PATH_RE, p))
+        return false;
+      if (anyMatch(PROSE_PATH_RE, p))
+        return false;
+      return anyMatch(CONTRACT_PATH_RE, p);
+    }
+    function changedLines(call) {
+      if (call.diff) {
+        return call.diff.split("\n").filter((l) => l.startsWith("+") || l.startsWith("-")).map((l) => l.slice(1));
+      }
+      const out = [];
+      const a = call.arguments;
+      const pushSetDiff = (oldS, newS) => {
+        const oldL = typeof oldS === "string" ? oldS.split("\n") : [];
+        const newL = typeof newS === "string" ? newS.split("\n") : [];
+        const oldSet = new Set(oldL.map((l) => l.trim()));
+        const newSet = new Set(newL.map((l) => l.trim()));
+        for (const l of newL)
+          if (!oldSet.has(l.trim()))
+            out.push(l);
+        for (const l of oldL)
+          if (!newSet.has(l.trim()))
+            out.push(l);
+      };
+      if (a && typeof a === "object") {
+        pushSetDiff(a.old_string, a.new_string);
+        const contents = a.contents ?? a.content;
+        if (typeof contents === "string")
+          for (const l of contents.split("\n"))
+            out.push(l);
+        const patch = a.patch;
+        if (typeof patch === "string") {
+          for (const l of patch.split("\n"))
+            if (l.startsWith("+") || l.startsWith("-"))
+              out.push(l.slice(1));
+        }
+        const edits = a.edits;
+        if (Array.isArray(edits)) {
+          for (const e of edits)
+            if (e && typeof e === "object")
+              pushSetDiff(e.old_string, e.new_string);
+        }
+      }
+      return out;
+    }
+    function migrationDestructive(text) {
+      return /\bDROP\s+COLUMN\b|\bALTER\s+COLUMN\b|new_column_name|alter_column|\bRENAME\b|DROP\s+TABLE|DROP\s+CONSTRAINT/i.test(text);
+    }
+    function migrationIndexOnly(text) {
+      return /CREATE\s+INDEX/i.test(text) && !migrationDestructive(text) && !/ADD\s+COLUMN|DROP\b/i.test(text);
+    }
+    function gateDisabled(call) {
+      const paths = allPaths(call);
+      if (!paths.some((p) => anyMatch(GATE_PATH_RE, p)))
+        return false;
+      const text = changeText(call);
+      if (!GATE_KEYWORD_RE.test(text))
+        return false;
+      const lines = changedLines(call);
+      const commentedOut = lines.some((l) => /^\s*(#|\/\/)/.test(l) && GATE_KEYWORD_RE.test(l));
+      const weakened = anyMatch(REAL_CHANGE_RE, text) || /continue-on-error|if:\s*false|:\s*off\b|ignore\s*:/i.test(text);
+      return commentedOut || weakened;
+    }
+    function lockfileContractChange(call) {
+      const paths = allPaths(call);
+      if (!paths.some((p) => LOCKFILE_RE.test(p)))
+        return false;
+      const text = changeText(call);
+      const contractPkg = /@[\w.-]+\/(openapi|graphql|proto|asyncapi|schema)\b|(openapi|graphql|proto|asyncapi|schema)@\d/i.test(text);
+      if (!contractPkg)
+        return false;
+      return /"resolved"\s*:/i.test(text) || /@\d+\.\d+\.\d+/.test(text) || /@\d+['":]/.test(text);
+    }
+    function isInertOnly(call) {
+      const text = changeText(call);
+      const paths = allPaths(call);
+      if (paths.some((p) => LOCKFILE_RE.test(p)) && !lockfileContractChange(call)) {
+        if (/"integrity"\s*:/i.test(text) && !/"resolved"\s*:/i.test(text))
+          return true;
+      }
+      if (paths.some((p) => /migrations?\/|alembic\//i.test(p)) && migrationIndexOnly(text))
+        return true;
+      if (paths.some((p) => anyMatch(GATE_PATH_RE, p))) {
+        if (!GATE_KEYWORD_RE.test(text) && !anyMatch(REAL_CHANGE_RE, text))
+          return true;
+        return false;
+      }
+      const cmd = commandText(call);
+      if (cmd && FORMATTER_RE.test(cmd))
+        return true;
+      if (/\b(examples?|value)\s*:/i.test(text) && !anyMatch(REAL_CHANGE_RE, text))
+        return true;
+      const lines = changedLines(call);
+      if (lines.length === 0)
+        return false;
+      let sawReal = false;
+      let sawInert = false;
+      for (const raw of lines) {
+        const t = raw.trim();
+        if (t === "") {
+          sawInert = true;
+          continue;
+        }
+        if (/^#|^\/\/|^\/\*|\*\/|^\*/.test(t)) {
+          sawInert = true;
+          continue;
+        }
+        if (/^```/.test(t)) {
+          sawInert = true;
+          continue;
+        }
+        if (/^["'].*["']$/.test(t) && !t.includes(":")) {
+          sawInert = true;
+          continue;
+        }
+        if (/generated|timestamp/i.test(t)) {
+          sawInert = true;
+          continue;
+        }
+        if (anyMatch(INERT_KEY_RE, t)) {
+          sawInert = true;
+          continue;
+        }
+        if (anyMatch(REAL_CHANGE_RE, t) || anyMatch(CONTRACT_STRUCTURE_RE, t) || anyMatch(CONTRACT_CONTENT_RE, t)) {
+          sawReal = true;
+          continue;
+        }
+        if (/^[\w"']+\??\s*:\s*\S/.test(t)) {
+          sawReal = true;
+          continue;
+        }
+      }
+      return sawInert && !sawReal;
+    }
+    function realChangePresent(call) {
+      const text = changeText(call);
+      if (migrationDestructive(text))
+        return true;
+      if (gateDisabled(call))
+        return true;
+      if (lockfileContractChange(call))
+        return true;
+      for (const raw of changedLines(call)) {
+        const t = raw.trim();
+        if (anyMatch(INERT_KEY_RE, t))
+          continue;
+        if (anyMatch(REAL_CHANGE_RE, t))
+          return true;
+        if (/^[\w"']+\??\s*:\s*\S/.test(t) && !/^(paths|components|info|servers|channels|tools|get|post|put|delete|patch)\s*:/i.test(t))
+          return true;
+      }
+      return false;
+    }
+    function intentMentionsContract(intent) {
+      if (!intent)
+        return false;
+      return /openapi|swagger|graphql|protobuf|\bproto\b|asyncapi|mcp\s*manifest|mcp\.json|json\s*schema|\bschema\b|required\s+field|\bendpoint\b|wire\s*format|api\s*spec|contract\s*(file|change|surface)/i.test(intent);
+    }
+    function commandMutatesContract(call) {
+      const cmd = commandText(call);
+      if (!cmd)
+        return false;
+      if (FORMATTER_RE.test(cmd))
+        return false;
+      const touchesContract = allPaths(call).some(isContractPath) || /(>|>>|-o\s|mv\s|ln\s+-sf?\s|git\s+mv\s|cp\s)[^\n|]*(openapi|swagger|asyncapi|\.graphql|\.gql|\.proto|\.pb\b|mcp[.-]?\w*\.json|schema\.prisma|spec\.(ya?ml|json))/i.test(cmd) || anyMatch(CONTRACT_CONTENT_RE, cmd);
+      const mutates = /(>|>>|\bmv\b|\bcp\b|\bln\s|git\s+mv|curl|wget|-o\b|base64\s+-d|xxd|\bjq\b|\bsed\b|\btee\b|echo|printf|\bcat\b)/i.test(cmd);
+      return touchesContract && mutates;
+    }
+    var DEEP_MAX_DEPTH = 8;
+    var DEEP_MAX_BYTES = 262144;
+    var DEEP_DECODE_MAX_BYTES = 65536;
+    var DEEP_DECODE_LEVELS = 3;
+    var OPAQUE_MIN_LEN = 40;
+    function looksLikePath(v) {
+      return v.length > 0 && v.length <= 256 && !/[\n\r{}<>]/.test(v) && /(^|\/)[\w.@-]+\.[A-Za-z0-9]+$/.test(v.trim());
+    }
+    function decodeCandidates(v) {
+      const out = [];
+      const push = (s) => {
+        if (s && s.length > 0 && s.length <= DEEP_DECODE_MAX_BYTES)
+          out.push(s);
+      };
+      const compact = v.replace(/\s+/g, "");
+      if (compact.length >= 16 && compact.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(compact)) {
+        try {
+          push(Buffer.from(compact, "base64").toString("utf8"));
+        } catch {
+        }
+        try {
+          const b = Buffer.from(compact, "base64");
+          push((0, node_zlib_1.gunzipSync)(b).toString("utf8"));
+        } catch {
+        }
+      }
+      if (compact.length >= 16 && compact.length % 2 === 0 && /^[0-9a-fA-F]+$/.test(compact)) {
+        try {
+          push(Buffer.from(compact, "hex").toString("utf8"));
+        } catch {
+        }
+      }
+      if (/%[0-9a-fA-F]{2}/.test(v)) {
+        try {
+          push(decodeURIComponent(v));
+        } catch {
+        }
+      }
+      if (/\\["\\/]|^\s*"/.test(v)) {
+        try {
+          const p = JSON.parse(v);
+          if (typeof p === "string")
+            push(p);
+        } catch {
+        }
+      }
+      return out;
+    }
+    function looksEncoded(v) {
+      const c = v.replace(/\s+/g, "");
+      if (c.length < OPAQUE_MIN_LEN)
+        return false;
+      return /^[A-Za-z0-9+/]+={0,2}$/.test(c) && c.length % 4 === 0 || /^[0-9a-fA-F]+$/.test(c) && c.length % 2 === 0;
+    }
+    function deepArgScan(call) {
+      const acc = { contractContent: false, pathContractSsot: false, pathNonSsot: false, pathLikeCount: 0, proseCount: 0, opaque: false, capHit: false };
+      let budget = DEEP_MAX_BYTES;
+      const scanString = (s) => {
+        if (looksLikePath(s)) {
+          acc.pathLikeCount++;
+          if (anyMatch(NON_SSOT_PATH_RE, s))
+            acc.pathNonSsot = true;
+          else if (anyMatch(PROSE_PATH_RE, s))
+            acc.proseCount++;
+          else if (isContractPath(s))
+            acc.pathContractSsot = true;
+          return;
+        }
+        if (anyMatch(CONTRACT_CONTENT_RE, s) || anyMatch(CONTRACT_STRUCTURE_RE, s)) {
+          acc.contractContent = true;
+          return;
+        }
+        let level = [s];
+        for (let d = 0; d < DEEP_DECODE_LEVELS && !acc.contractContent; d++) {
+          const next = [];
+          for (const val of level) {
+            for (const dec of decodeCandidates(val)) {
+              if (anyMatch(CONTRACT_CONTENT_RE, dec) || anyMatch(CONTRACT_STRUCTURE_RE, dec)) {
+                acc.contractContent = true;
+                break;
+              }
+              next.push(dec);
+            }
+            if (acc.contractContent)
+              break;
+          }
+          level = next;
+        }
+        if (!acc.contractContent && looksEncoded(s) && level.every((x) => !isReadableText(x)))
+          acc.opaque = true;
+      };
+      const walk = (node, depth) => {
+        if (acc.capHit || budget <= 0)
+          return;
+        if (depth > DEEP_MAX_DEPTH) {
+          acc.capHit = true;
+          return;
+        }
+        if (typeof node === "string") {
+          budget -= node.length;
+          if (budget <= 0) {
+            acc.capHit = true;
+            return;
+          }
+          scanString(node);
+        } else if (Array.isArray(node)) {
+          for (const el of node) {
+            if (acc.capHit)
+              break;
+            walk(el, depth + 1);
+          }
+        } else if (node && typeof node === "object") {
+          for (const val of Object.values(node)) {
+            if (acc.capHit)
+              break;
+            walk(val, depth + 1);
+          }
+        }
+      };
+      try {
+        walk(call.arguments, 0);
+      } catch {
+        acc.capHit = true;
+      }
+      return acc;
+    }
+    function isReadableText(s) {
+      if (!s)
+        return false;
+      let printable = 0;
+      const n = Math.min(s.length, 512);
+      for (let i = 0; i < n; i++) {
+        const c = s.charCodeAt(i);
+        if (c === 9 || c === 10 || c === 13 || c >= 32 && c < 127)
+          printable++;
+      }
+      return printable / n > 0.85;
+    }
+    exports2.builtinDetector = {
+      version: exports2.DETECTOR_VERSION,
+      detect(call) {
+        const signals = [];
+        const artifacts = Array.isArray(call.artifacts) ? call.artifacts : [];
+        if (artifacts.length > 0)
+          return { trigger: true, artifacts, signals: ["explicit_artifacts"], confident: true };
+        if (READ_ONLY_TOOLS.has(String(call.toolName).toLowerCase()) && !commandMutatesContract(call)) {
+          return { trigger: false, artifacts: [], signals: ["non_mutating_tool"], confident: true };
+        }
+        const paths = allPaths(call);
+        const contractPath = paths.some(isContractPath);
+        const codeContractPath = paths.some((p) => anyMatch(CODE_CONTRACT_PATH_RE, p) && !anyMatch(NON_SSOT_PATH_RE, p));
+        const change = changeText(call);
+        const inProse = paths.length > 0 && paths.every((p) => anyMatch(PROSE_PATH_RE, p));
+        const contentMarker = anyMatch(CONTRACT_CONTENT_RE, change) && !paths.some((p) => anyMatch(NON_SSOT_PATH_RE, p)) && !inProse;
+        const shellMutation = commandMutatesContract(call);
+        const gate = gateDisabled(call);
+        const lockContract = lockfileContractChange(call);
+        const contractSurface = contractPath || contentMarker || shellMutation || codeContractPath || gate || lockContract;
+        if (contractSurface) {
+          if (shellMutation) {
+            signals.push("shell_mutates_contract");
+            return { trigger: true, artifacts, signals, confident: true };
+          }
+          if (gate) {
+            signals.push("contract_gate_disabled");
+            return { trigger: true, artifacts, signals, confident: true };
+          }
+          if (lockContract) {
+            signals.push("lockfile_contract_redirect");
+            return { trigger: true, artifacts, signals, confident: true };
+          }
+          if (isInertOnly(call)) {
+            signals.push("inert_change_only");
+            return { trigger: false, artifacts: [], signals, confident: true };
+          }
+          if (realChangePresent(call) || contentMarker || anyMatch(CONTRACT_STRUCTURE_RE, change)) {
+            signals.push("contract_change");
+            return { trigger: true, artifacts, signals, confident: true };
+          }
+          signals.push("ambiguous_contract_surface");
+          return { trigger: true, artifacts, signals, confident: false };
+        }
+        const deep = deepArgScan(call);
+        if (deep.contractContent || deep.pathContractSsot) {
+          const deepInProse = deep.pathLikeCount > 0 && deep.proseCount === deep.pathLikeCount && !deep.pathContractSsot;
+          if (!deep.pathNonSsot && !deepInProse && !isInertOnly(call)) {
+            signals.push(deep.contractContent ? "arguments_deep_contract" : "arguments_deep_path");
+            return { trigger: true, artifacts, signals, confident: false };
+          }
+        }
+        if (deep.opaque || deep.capHit) {
+          signals.push(deep.capHit ? "arguments_scan_capped" : "arguments_opaque");
+          return { trigger: true, artifacts, signals, confident: false };
+        }
+        if (intentMentionsContract(call.intent)) {
+          signals.push("intent_contract_reference");
+          return { trigger: true, artifacts, signals, confident: false };
+        }
+        signals.push("no_contract_signal");
+        return { trigger: false, artifacts: [], signals, confident: true };
+      }
+    };
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/receipt-binding.js
+var require_receipt_binding = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/receipt-binding.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.canonicalJson = canonicalJson;
+    exports2.computeBodyHash = computeBodyHash;
+    exports2.bindReceiptToEnvelope = bindReceiptToEnvelope;
+    var node_crypto_1 = require("node:crypto");
+    function canonicalJson(value) {
+      return encode(value);
+    }
+    function encode(value) {
+      if (value === null)
+        return "null";
+      const t = typeof value;
+      if (t === "boolean" || t === "string")
+        return JSON.stringify(value);
+      if (t === "number") {
+        if (!Number.isFinite(value))
+          throw new TypeError("canonicalJson: non-finite number is not representable");
+        return JSON.stringify(value);
+      }
+      if (t === "undefined")
+        throw new TypeError("canonicalJson: undefined is not representable (omit the key instead)");
+      if (Array.isArray(value))
+        return `[${value.map(encode).join(",")}]`;
+      if (t === "object") {
+        const obj = value;
+        const keys = Object.keys(obj).sort();
+        return `{${keys.map((k) => `${JSON.stringify(k)}:${encode(obj[k])}`).join(",")}}`;
+      }
+      throw new TypeError(`canonicalJson: unsupported type ${t}`);
+    }
+    function sha256hex(s) {
+      return (0, node_crypto_1.createHash)("sha256").update(s).digest("hex");
+    }
+    function computeBodyHash(envelope) {
+      const rest = { ...envelope };
+      delete rest.receipt;
+      delete rest.decision_body_hash;
+      return `sha256:${sha256hex(canonicalJson(rest))}`;
+    }
+    function bindReceiptToEnvelope(envelope, vr, ctx = {}) {
+      if (!envelope)
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: "no envelope" };
+      if (!vr || vr.valid !== true)
+        return { ok: false, cause: "RECEIPT_UNVERIFIED", detail: `valid=${vr ? vr.valid : "none"}` };
+      if (vr.status !== "VERIFIED_CURRENT") {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: `status ${vr.status ?? "unknown"} != VERIFIED_CURRENT` };
+      }
+      const payload = vr.payload || {};
+      const localBh = computeBodyHash(envelope);
+      if (typeof payload.bh !== "string" || payload.bh !== localBh) {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: "decision_body_hash mismatch (receipt was signed over a different envelope)" };
+      }
+      if (typeof payload.fp !== "string" || payload.fp !== envelope.fingerprint) {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: "verdict_fingerprint mismatch" };
+      }
+      const requestedOp = ctx.operation ?? "tool_call";
+      if (envelope.operation != null && requestedOp != null && envelope.operation !== requestedOp) {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: `operation ${String(envelope.operation)} != ${String(requestedOp)}` };
+      }
+      if (ctx.environment != null && envelope.environment != null && envelope.environment !== ctx.environment) {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: `environment ${String(envelope.environment)} != ${String(ctx.environment)}` };
+      }
+      if (ctx.audience != null && envelope.audience != null && envelope.audience !== ctx.audience) {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: `audience ${String(envelope.audience)} != ${String(ctx.audience)}` };
+      }
+      return { ok: true };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/enforcement-gate.js
+var require_enforcement_gate = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/enforcement-gate.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.computeArtifactDigest = computeArtifactDigest;
+    exports2.computeBundleFingerprint = computeBundleFingerprint;
+    exports2.evaluateEnvelope = evaluateEnvelope;
+    var node_crypto_1 = require("node:crypto");
+    var DECISION_RANK = { ALLOW: 0, WARN: 1, REQUIRE_APPROVAL: 2, BLOCK: 3 };
+    var ACTION_TO_DECISION = {
+      CONTINUE: "ALLOW",
+      CONTINUE_WITH_MONITORING: "WARN",
+      REQUEST_APPROVAL: "REQUIRE_APPROVAL",
+      STOP: "BLOCK"
+    };
+    var DECISION_TO_ACTION = {
+      ALLOW: "CONTINUE",
+      WARN: "CONTINUE_WITH_MONITORING",
+      REQUIRE_APPROVAL: "REQUEST_APPROVAL",
+      BLOCK: "STOP"
+    };
+    function isDecision(v) {
+      return v === "ALLOW" || v === "WARN" || v === "REQUIRE_APPROVAL" || v === "BLOCK";
+    }
+    function isAction(v) {
+      return v === "CONTINUE" || v === "CONTINUE_WITH_MONITORING" || v === "REQUEST_APPROVAL" || v === "STOP";
+    }
+    var NUL = "";
+    function sha256hex(s) {
+      return (0, node_crypto_1.createHash)("sha256").update(s).digest("hex");
+    }
+    function specStr(v) {
+      return v == null ? "" : typeof v === "string" ? v : JSON.stringify(v);
+    }
+    function computeArtifactDigest(artifacts) {
+      const preimage = artifacts.slice().sort((a, b) => `${a.type}${NUL}${a.id}` < `${b.type}${NUL}${b.id}` ? -1 : 1).map((a) => `${sha256hex(specStr(a.before))}${sha256hex(specStr(a.after))}`).join(NUL);
+      return `sha256:${sha256hex(preimage)}`;
+    }
+    function computeBundleFingerprint(artifacts) {
+      const parts = artifacts.slice().sort((a, b) => `${a.type}${NUL}${a.id}` < `${b.type}${NUL}${b.id}` ? -1 : 1).map((a) => [a.type, a.id, sha256hex(specStr(a.before)), sha256hex(specStr(a.after))].join(NUL));
+      return `sha256:${sha256hex(parts.join(NUL))}`;
+    }
+    function evaluateEnvelope(response, envelope, executionAction, sentArtifacts) {
+      const dec = envelope.decision;
+      if (!isDecision(dec)) {
+        return { verdict: "fail-closed", cause: "DECISION_INCONSISTENT", detail: `decision=${JSON.stringify(dec)} is missing/invalid` };
+      }
+      const signals = [dec, ACTION_TO_DECISION[executionAction]];
+      const top = response && typeof response === "object" ? response : {};
+      if (isDecision(top.decision))
+        signals.push(top.decision);
+      if (isAction(top.execution_action))
+        signals.push(ACTION_TO_DECISION[top.execution_action]);
+      const effective = signals.reduce((a, b) => DECISION_RANK[b] > DECISION_RANK[a] ? b : a);
+      if (DECISION_RANK[effective] >= DECISION_RANK.REQUIRE_APPROVAL) {
+        return { verdict: "block-strict", decision: effective };
+      }
+      if (DECISION_TO_ACTION[dec] !== executionAction) {
+        return { verdict: "fail-closed", cause: "DECISION_INCONSISTENT", detail: `decision=${dec} \u2260 execution_action=${executionAction}` };
+      }
+      if (envelope.safe_for_agent === false) {
+        return { verdict: "fail-closed", cause: "DECISION_INCONSISTENT", detail: "safe_for_agent=false on an allow-class decision" };
+      }
+      const degradedReasons = envelope.degraded_reasons;
+      if (envelope.analysis_complete === false || Array.isArray(degradedReasons) && degradedReasons.length > 0 || envelope.degraded === true || envelope.coverage_gap === true) {
+        return { verdict: "fail-closed", cause: "ANALYSIS_DEGRADED", detail: "analysis degraded / incomplete" };
+      }
+      if (Array.isArray(sentArtifacts) && sentArtifacts.length > 0 && typeof envelope.artifact_digest === "string" && envelope.artifact_digest !== computeArtifactDigest(sentArtifacts)) {
+        return { verdict: "fail-closed", cause: "ARTIFACT_MISMATCH", detail: "artifact_digest \u2260 locally-recomputed digest of sent artifacts" };
+      }
+      return { verdict: "allow", kind: effective === "ALLOW" ? "ALLOW" : "MONITOR" };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/guard.js
+var require_guard = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/guard.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.guardToolCall = guardToolCall;
+    var node_crypto_1 = require("node:crypto");
+    var sdk_1 = require_cjs3();
+    var detector_js_1 = require_detector();
+    var receipt_binding_js_1 = require_receipt_binding();
+    var enforcement_gate_js_1 = require_enforcement_gate();
+    var breakers = /* @__PURE__ */ new WeakMap();
+    var nowMs = () => Date.now();
+    var iso = () => (/* @__PURE__ */ new Date()).toISOString();
+    function emit(config, e) {
+      if (config.onEvent) {
+        try {
+          config.onEvent(e);
+        } catch {
+        }
+      }
+    }
+    function fingerprint(call) {
+      const canon = JSON.stringify({ toolName: call.toolName, arguments: call.arguments, artifacts: call.artifacts, filesTouched: call.filesTouched, diff: call.diff });
+      return "sha256:" + (0, node_crypto_1.createHash)("sha256").update(canon).digest("hex");
+    }
+    function breakerRecord(config) {
+      let s = breakers.get(config);
+      if (!s) {
+        s = { fails: [] };
+        breakers.set(config, s);
+      }
+      s.fails.push(nowMs());
+    }
+    function breakerTripped(config) {
+      const s = breakers.get(config);
+      if (!s)
+        return false;
+      const win = config.breakerWindowMs ?? 6e4;
+      const t = nowMs();
+      s.fails = s.fails.filter((x) => t - x < win);
+      return s.fails.length >= (config.maxUnavailablePerWindow ?? 3);
+    }
+    function classifyError(err, config) {
+      const e = err;
+      const name = e?.name;
+      const status = e?.status ?? e?.body?.status;
+      if (name === "TimeoutError" || name === "AbortError" || e?.code === "ABORT_ERR")
+        return { cause: "TIMEOUT", integrity: false };
+      if (status === 429 || name === "RateLimitError")
+        return { cause: "RATE_LIMITED", integrity: false };
+      if (status === 413)
+        return { cause: "PAYLOAD_TOO_LARGE", integrity: true };
+      if (status === 422)
+        return { cause: "REQUEST_REJECTED", integrity: true };
+      if (status === 400 || status === 401 || status === 409)
+        return { cause: "REQUEST_REJECTED", integrity: true };
+      if (typeof status === "number" && status >= 500)
+        return { cause: "SERVER_ERROR", integrity: false };
+      if (name === "TypeError" || /fetch failed|network|ENOTFOUND|ECONNREFUSED|EAI_AGAIN/i.test(String(e?.message)))
+        return { cause: "NETWORK", integrity: false };
+      if (name === "ApiError")
+        return { cause: "SERVER_ERROR", integrity: false };
+      return { cause: "INVALID_RESPONSE", integrity: true };
+    }
+    function withTimeout(p, ms) {
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(Object.assign(new Error(`preflight timed out after ${ms}ms`), { name: "TimeoutError" })), Math.max(1, ms));
+        p.then((v) => {
+          clearTimeout(timer);
+          resolve(v);
+        }, (e) => {
+          clearTimeout(timer);
+          reject(e);
+        });
+      });
+    }
+    async function preflightWithRetry(config, request) {
+      const retries = config.retries ?? 1;
+      const timeoutMs = config.timeoutMs ?? 2e3;
+      const budget = config.totalBudgetMs ?? 4500;
+      const start = nowMs();
+      let last = { cause: "TIMEOUT", integrity: false };
+      for (let attempt = 0; attempt <= retries; attempt++) {
+        const remaining = budget - (nowMs() - start);
+        if (remaining <= 0)
+          return { ok: false, cause: "TIMEOUT", integrity: false };
+        try {
+          const response = await withTimeout(config.client.preflightChangeSet(request), Math.min(timeoutMs, remaining));
+          return { ok: true, response };
+        } catch (err) {
+          last = classifyError(err, config);
+          if (last.integrity)
+            return { ok: false, ...last };
+        }
+      }
+      return { ok: false, ...last };
+    }
+    async function verifyEnvelope(config, envelope) {
+      if (!envelope)
+        return { verified: null };
+      if (config.verifyReceipts === false)
+        return { verified: null };
+      const token = envelope.receipt?.token;
+      if (!token)
+        return { verified: null };
+      try {
+        const r = await config.client.verifyReceipt(token);
+        const bind = (0, receipt_binding_js_1.bindReceiptToEnvelope)(envelope, r, { operation: config.operation, environment: config.environment, audience: config.audience });
+        if (bind.ok)
+          return { verified: envelope };
+        emit(config, { type: "receipt_unverified", at: iso(), decisionId: envelope.decision_id, cause: bind.detail });
+        return { verified: null, cause: bind.cause };
+      } catch {
+        return { verified: null, cause: "RECEIPT_UNVERIFIED" };
+      }
+    }
+    async function runEnforced(config, factory, approved, redacted) {
+      emit(config, { type: "execution_started", at: iso(), action: approved.action, decisionId: approved.envelope.decision_id });
+      try {
+        const result = await factory(approved.envelope, redacted);
+        return { executionAttempted: true, executed: true, enforced: true, result, verdict: approved, preflighted: true };
+      } catch (error) {
+        emit(config, { type: "factory_error", at: iso(), action: approved.action });
+        return { executionAttempted: true, executed: false, enforced: true, error, verdict: approved, preflighted: true };
+      }
+    }
+    async function runUnenforced(config, factory, envelope, verdict, preflighted, redacted) {
+      emit(config, { type: "execution_started", at: iso() });
+      try {
+        const result = await factory(envelope, redacted);
+        return { executionAttempted: true, executed: true, enforced: false, result, verdict, preflighted };
+      } catch (error) {
+        emit(config, { type: "factory_error", at: iso() });
+        return { executionAttempted: true, executed: false, enforced: false, error, verdict, preflighted };
+      }
+    }
+    function blocked(verdict, preflighted) {
+      return { executionAttempted: false, executed: false, enforced: false, verdict, preflighted };
+    }
+    function hasAnalyzableContent(artifacts) {
+      if (!Array.isArray(artifacts) || artifacts.length === 0)
+        return false;
+      return artifacts.some((a) => {
+        if (!a || typeof a !== "object")
+          return false;
+        const before = a.before;
+        const after = a.after;
+        return typeof before === "string" && before.length > 0 || typeof after === "string" && after.length > 0;
+      });
+    }
+    function unavailableVerdict(parts, count) {
+      return { kind: "UNAVAILABLE", decisionMissing: true, unavailableCount: count, ...parts };
+    }
+    async function guardToolCall(call, executeFactory, config) {
+      const failPolicy = config.failPolicy ?? "closed";
+      let redacted;
+      try {
+        redacted = config.redactor ? config.redactor(call) : call;
+      } catch {
+        breakerRecord(config);
+        return closedIntegrity(config, "CONFIG_ERROR", failPolicy);
+      }
+      const inputFp = fingerprint(redacted);
+      const detector = config.detector ?? detector_js_1.builtinDetector;
+      let detection;
+      try {
+        detection = detector.detect(redacted);
+      } catch {
+        breakerRecord(config);
+        return closedIntegrity(config, "DETECTOR_ERROR", failPolicy);
+      }
+      const suppressedByStrict = config.requireExplicitArtifacts === true && redacted.nonContract === true && (!detection.artifacts || detection.artifacts.length === 0) && detection.confident && !detection.trigger;
+      if (!detection.trigger || suppressedByStrict) {
+        emit(config, { type: "detection_skip", at: iso(), signals: detection.signals, detectorVersion: detector.version });
+        const verdict = { kind: "SKIPPED", reason: "NOT_A_CONTRACT_CALL", signals: detection.signals, detectorVersion: detector.version };
+        return runUnenforced(config, executeFactory, null, verdict, false, redacted);
+      }
+      if (!hasAnalyzableContent(detection.artifacts)) {
+        emit(config, { type: "artifact_content_missing", at: iso(), cause: "MISSING_ARTIFACT_CONTENT", signals: detection.signals });
+        const count = breakers.get(config)?.fails.length ?? 0;
+        const v = unavailableVerdict({ cause: "MISSING_ARTIFACT_CONTENT", failPolicy, resolution: "CLOSED", action: "STOP" }, count);
+        return blocked(v, false);
+      }
+      if (failPolicy === "lkg" && !config.lkg) {
+        breakerRecord(config);
+        return closedIntegrity(config, "CONFIG_ERROR", failPolicy);
+      }
+      const request = {
+        artifacts: detection.artifacts,
+        context: { operation: config.operation ?? "tool_call", environment: config.environment, audience: config.audience },
+        previous_receipt: void 0,
+        idempotency_key: void 0
+      };
+      const cap = config.maxPayloadBytes ?? 1e6;
+      if (Buffer.byteLength(JSON.stringify(request), "utf8") > cap) {
+        breakerRecord(config);
+        return closedIntegrity(config, "PAYLOAD_TOO_LARGE", failPolicy);
+      }
+      emit(config, { type: "preflight_start", at: iso() });
+      const pf = await preflightWithRetry(config, request);
+      if (!pf.ok) {
+        breakerRecord(config);
+        const count = breakers.get(config)?.fails.length ?? 1;
+        if (pf.integrity) {
+          emit(config, { type: "breaker_tripped", at: iso(), cause: pf.cause });
+          const v2 = unavailableVerdict({ cause: pf.cause, failPolicy, resolution: "CLOSED", action: "STOP" }, count);
+          return blocked(v2, false);
+        }
+        const availCause = pf.cause;
+        if (failPolicy === "open" && !breakerTripped(config)) {
+          emit(config, { type: "preflight_unavailable", at: iso(), cause: availCause, action: "CONTINUE" });
+          const v2 = unavailableVerdict({ cause: availCause, failPolicy: "open", resolution: "OPEN_PASSTHROUGH", action: "CONTINUE" }, count);
+          return runUnenforced(config, executeFactory, null, v2, false, redacted);
+        }
+        if (failPolicy === "lkg") {
+          const lkg = await tryLkg(config, inputFp);
+          if (lkg) {
+            emit(config, { type: "preflight_unavailable", at: iso(), cause: availCause, action: lkg.action });
+            const v2 = unavailableVerdict({ cause: availCause, failPolicy: "lkg", resolution: "LKG_SUBSTITUTION", action: lkg.action, lkgEnvelope: lkg.envelope }, count);
+            return runUnenforced(config, executeFactory, lkg.envelope, v2, false, redacted);
+          }
+        }
+        if (breakerTripped(config))
+          emit(config, { type: "breaker_tripped", at: iso(), cause: availCause });
+        const v = unavailableVerdict({ cause: availCause, failPolicy, resolution: "CLOSED", action: "STOP" }, count);
+        return blocked(v, false);
+      }
+      const rd = (0, sdk_1.readDecision)(pf.response);
+      if (rd.reason === "UNREADABLE_DECISION" || !rd.envelope) {
+        breakerRecord(config);
+        return closedIntegrity(config, "SCHEMA_INVALID", failPolicy);
+      }
+      const envelope = rd.envelope;
+      const expired = isExpired(envelope);
+      const bindResult = await verifyEnvelope(config, envelope);
+      const verified = bindResult.verified;
+      const receiptVerified = !!verified;
+      if (!receiptVerified)
+        emit(config, { type: "receipt_unverified", at: iso(), decisionId: envelope.decision_id });
+      emit(config, { type: "preflight_result", at: iso(), action: rd.executionAction, decisionId: envelope.decision_id });
+      if (config.verifyReceipts !== false && !receiptVerified && envelope.receipt?.token) {
+        breakerRecord(config);
+        return closedIntegrity(config, bindResult.cause ?? "RECEIPT_UNVERIFIED", failPolicy);
+      }
+      const gate = (0, enforcement_gate_js_1.evaluateEnvelope)(pf.response, envelope, rd.executionAction, detection.artifacts);
+      if (gate.verdict === "fail-closed") {
+        breakerRecord(config);
+        return closedIntegrity(config, gate.cause, failPolicy);
+      }
+      if (gate.verdict === "block-strict") {
+        return gate.decision === "BLOCK" ? blocked({ kind: "BLOCK", action: "STOP", envelope, receiptVerified }, true) : blocked({ kind: "APPROVAL", action: "REQUEST_APPROVAL", envelope, receiptVerified }, true);
+      }
+      const kind = gate.kind;
+      if (expired) {
+        breakerRecord(config);
+        return closedIntegrity(config, "SCHEMA_INVALID", failPolicy);
+      }
+      const sinkWired = !!config.onEvent;
+      if (kind === "MONITOR") {
+        if (sinkWired)
+          emit(config, { type: "monitoring_required", at: iso(), decisionId: envelope.decision_id });
+        else
+          emit(config, { type: "monitoring_unwired", at: iso(), decisionId: envelope.decision_id });
+      }
+      if (config.observeOnly) {
+        emit(config, { type: "observe_only_passthrough", at: iso(), action: rd.executionAction });
+        const verdict = kind === "ALLOW" ? { kind: "ALLOW", action: "CONTINUE", envelope, receiptVerified } : { kind: "MONITOR", action: "CONTINUE_WITH_MONITORING", envelope, receiptVerified };
+        return runUnenforced(config, executeFactory, envelope, verdict, true, redacted);
+      }
+      const enforceable = receiptVerified && (kind === "ALLOW" || sinkWired);
+      if (enforceable) {
+        const approved = kind === "ALLOW" ? { kind: "ALLOW", action: "CONTINUE", envelope, receiptVerified: true } : { kind: "MONITOR", action: "CONTINUE_WITH_MONITORING", envelope, receiptVerified: true };
+        return runEnforced(config, executeFactory, approved, redacted);
+      }
+      breakerRecord(config);
+      return closedIntegrity(config, receiptVerified ? "MONITORING_UNWIRED" : "RECEIPT_MISSING", failPolicy);
+    }
+    function closedIntegrity(config, cause, failPolicy) {
+      const count = breakers.get(config)?.fails.length ?? 1;
+      emit(config, { type: "breaker_tripped", at: iso(), cause });
+      const v = unavailableVerdict({ cause, failPolicy, resolution: "CLOSED", action: "STOP" }, count);
+      return blocked(v, false);
+    }
+    function isExpired(envelope) {
+      const exp = envelope.expires_at;
+      if (typeof exp !== "string")
+        return false;
+      const t = Date.parse(exp);
+      return Number.isFinite(t) && t < Date.now();
+    }
+    async function tryLkg(config, inputFp) {
+      if (!config.lkg)
+        return null;
+      let cached;
+      try {
+        cached = await config.lkg.get(inputFp);
+      } catch {
+        return null;
+      }
+      if (!cached)
+        return null;
+      const { verified } = await verifyEnvelope(config, cached);
+      if (!verified)
+        return null;
+      const dec = cached.decision ?? "";
+      if (dec !== "ALLOW" && dec !== "WARN")
+        return null;
+      if (isExpired(cached))
+        return null;
+      const maxAge = config.lkgMaxAgeMs ?? 9e5;
+      const evalAt = Date.parse(cached.evaluated_at);
+      if (Number.isFinite(evalAt) && Date.now() - evalAt > maxAge)
+        return null;
+      const bindings = [
+        cached.ruleset_hash,
+        cached.environment,
+        cached.operation,
+        cached.audience
+      ];
+      if (bindings.some((b) => b === void 0))
+        return null;
+      const action = dec === "ALLOW" ? "CONTINUE" : "CONTINUE_WITH_MONITORING";
+      return { envelope: verified, action };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/session-taint.js
+var require_session_taint = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/session-taint.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SessionTaintTracker = exports2.SESSION_TAINT_VERSION = void 0;
+    exports2.pathClass = pathClass;
+    exports2.emptySessionState = emptySessionState;
+    exports2.projectState = projectState;
+    exports2.classifyCommand = classifyCommand;
+    exports2.updateSession = updateSession;
+    exports2.computeTainted = computeTainted;
+    exports2.deriveKeySignal = deriveKeySignal;
+    exports2.evaluate = evaluate;
+    exports2.SESSION_TAINT_VERSION = "session-taint/1.0.0";
+    var NON_SSOT_RE = /(^|\/)(tests?|__tests__|fixtures?|__mocks__|src\/internal)\//i;
+    var PIPELINE_SCRATCH_RE = /(^|\/)(build|\.cache|codegen|idl)(\/|$)/i;
+    var PROSE_RE = /(^|\/)(README|CHANGELOG|LICENSE)(\.\w+)?$|\.md$/i;
+    var SSOT_PATH_RE = /(^|\/)(openapi|swagger|asyncapi)[^/]*\.(ya?ml|json)$|(^|\/)mcp\.json$|\.graphql$|\.gql$|(^|\/)idl\/.*\.proto$|(^|\/)specs?\/.*\.(ya?ml|json)$|openapi\.yaml|schema\.graphql|asyncapi\.yaml/i;
+    var MIGRATION_RE = /(^|\/)migrations?\//i;
+    var CODE_OR_CONFIG_RE = /\.(ts|tsx|js|jsx)$/i;
+    var CONTRACT_CONTENT_RE = /\bopenapi\s*[:=]|\bswagger\s*[:=]|\basyncapi\s*[:=]|syntax\s*=\s*["']proto3|["']inputSchema["']|\btype\s+Query\b|(^|\n)\s*paths\s*:/i;
+    var STAGING_NAME_RE = /\.b64$|enc\/|field-map|flags\.json|optional_fields|required_fields|service\.idl|frags\/|BREAKING_DROP/i;
+    var NON_SINK_RE = /validate-frags|gen-docs|reload-flags|snapshot-spec|prettier|npm test|npm install|npx prettier/i;
+    var SSOT_INVALIDATE_RE = /archive-old-spec/i;
+    var SSOT_SINK_RE = /dsl-to-openapi|merge-spec|publish-fixture|promote-spec|sync-graphql|b64join-write|decode-promote|apply-field-map|render-openapi|idl\/compile|generate-and-test|compile_spec_bundle|install-proto|install-mcp|promote-asyncapi|repack-extract|codegen\/build\.js|codegen\/apply|codegen\/render/i;
+    function pathClass(p) {
+      if (PROSE_RE.test(p))
+        return "prose";
+      if (NON_SSOT_RE.test(p) || PIPELINE_SCRATCH_RE.test(p))
+        return "scratch";
+      if (MIGRATION_RE.test(p))
+        return "migration";
+      if (SSOT_PATH_RE.test(p))
+        return "ssot";
+      if (CODE_OR_CONFIG_RE.test(p) || p.startsWith("src/") || p.startsWith("config/") || p === "package.json")
+        return "code_or_config";
+      return "other";
+    }
+    function emptySessionState() {
+      return {
+        scratch_writes: [],
+        contract_looking_scratch: [],
+        encoded_fragments: [],
+        intermediate_artifacts: [],
+        pending_renames: [],
+        optional_fields_added: [],
+        required_fields_declared: [],
+        ssot_paths_touched: [],
+        ssot_sink_events: [],
+        ssot_invalidated: false,
+        reverse_snapshot: false,
+        formatter_only_ssot: false,
+        store_keys: [],
+        tainted: false
+      };
+    }
+    function projectState(s) {
+      return {
+        scratch_writes: s.scratch_writes.slice(),
+        encoded_fragments: s.encoded_fragments.slice(),
+        pending_renames: s.pending_renames.map((r) => "drop" in r ? `drop:${r.drop}` : `${r.from}->${r.to}`),
+        optional_fields_added: s.optional_fields_added.slice(),
+        required_fields_declared: s.required_fields_declared.slice(),
+        ssot_paths_touched: s.ssot_paths_touched.slice(),
+        contract_looking_scratch: s.contract_looking_scratch.slice(),
+        intermediate_artifacts: s.intermediate_artifacts.slice(),
+        ssot_sink_events: s.ssot_sink_events.slice(),
+        ssot_invalidated: s.ssot_invalidated,
+        reverse_snapshot: s.reverse_snapshot,
+        formatter_only_ssot: s.formatter_only_ssot,
+        store_keys: s.store_keys.slice(),
+        tainted: s.tainted
+      };
+    }
+    function asRecord(args) {
+      return args && typeof args === "object" ? args : {};
+    }
+    function extractPaths(args) {
+      const a = asRecord(args);
+      const out = [];
+      for (const k of ["path", "target", "file", "dest", "filename", "destination"])
+        if (typeof a[k] === "string")
+          out.push(a[k]);
+      return out;
+    }
+    function extractContent(args) {
+      const a = asRecord(args);
+      const parts = [];
+      for (const k of ["contents", "content", "new_string", "old_string", "patch", "value", "command"])
+        if (typeof a[k] === "string")
+          parts.push(a[k]);
+      return parts.join("\n");
+    }
+    function isEncodedFragment(path, content) {
+      if (path && /part\.|enc\/|\.b64$|pkg\.part/i.test(path))
+        return true;
+      const c = content.replace(/\s+/g, "");
+      if (c.length >= 8 && c.length < 80 && /^[A-Za-z0-9+/=]+$/.test(c))
+        return true;
+      return false;
+    }
+    function classifyCommand(command, action, cfg = {}) {
+      const s = `${command || ""} ${action || ""}`;
+      const extraNon = cfg.extraNonSinkPatterns || [];
+      const extraSink = cfg.extraSinkPatterns || [];
+      if (NON_SINK_RE.test(s) || extraNon.some((r) => r.test(s)))
+        return "non_sink";
+      if (SSOT_INVALIDATE_RE.test(s))
+        return "ssot_invalidate";
+      if (SSOT_SINK_RE.test(s) || action === "compile_spec_bundle" || extraSink.some((r) => r.test(s)))
+        return "ssot_sink";
+      if (/snapshot/i.test(s))
+        return "reverse_snapshot";
+      if (/prettier|format/i.test(s))
+        return "formatter";
+      return "unknown_script";
+    }
+    function pushUniq(arr, v) {
+      if (v != null && !arr.includes(v))
+        arr.push(v);
+    }
+    function updateSession(state, call, cfg = {}) {
+      const s = JSON.parse(JSON.stringify(state));
+      const args = asRecord(call && call.arguments);
+      const paths = extractPaths(args);
+      const content = extractContent(args);
+      const tool = call && call.toolName;
+      if (tool === "store" && typeof args.key === "string") {
+        pushUniq(s.store_keys, args.key);
+        if (/spec_|api_|openapi|schema/i.test(args.key) || /BREAKING|ROUTE|FIELD|REMOVE|MANDATORY|required|optional/i.test(String(args.value))) {
+          pushUniq(s.intermediate_artifacts, `store:${args.key}`);
+        }
+      }
+      if (tool === "apply" && typeof args.action === "string") {
+        if (classifyCommand("", args.action, cfg) === "ssot_sink")
+          s.ssot_sink_events.push(args.action);
+      }
+      if (tool === "Bash" || typeof args.command === "string") {
+        const cmd = typeof args.command === "string" ? args.command : "";
+        const kind = classifyCommand(cmd, "", cfg);
+        if (kind === "ssot_sink")
+          s.ssot_sink_events.push(cmd);
+        if (kind === "ssot_invalidate")
+          s.ssot_invalidated = true;
+        if (kind === "reverse_snapshot")
+          s.reverse_snapshot = true;
+        if (kind === "formatter" && (SSOT_PATH_RE.test(cmd) || /openapi|swagger|asyncapi|\.graphql|\.gql|mcp\.json|schema/i.test(cmd)))
+          s.formatter_only_ssot = true;
+      }
+      for (const p of paths) {
+        const pc = pathClass(p);
+        const isScratch = pc === "scratch" || NON_SSOT_RE.test(p) || PIPELINE_SCRATCH_RE.test(p);
+        if (isScratch) {
+          pushUniq(s.scratch_writes, p);
+          if (CONTRACT_CONTENT_RE.test(content) || STAGING_NAME_RE.test(p + content))
+            pushUniq(s.contract_looking_scratch, p);
+          if (PIPELINE_SCRATCH_RE.test(p))
+            pushUniq(s.intermediate_artifacts, p);
+          if (isEncodedFragment(p, content) || /\.b64$/i.test(p) || /enc\//i.test(p) || /pkg\.part/i.test(p))
+            pushUniq(s.encoded_fragments, p);
+          if (/field-map|flags\.json|optional_fields|required_fields|\.idl$/i.test(p))
+            pushUniq(s.intermediate_artifacts, p);
+        }
+        if (pc === "ssot" && !(tool === "Bash" && /prettier/i.test(typeof args.command === "string" ? args.command : "")))
+          pushUniq(s.ssot_paths_touched, p);
+        if (/field-map/i.test(p)) {
+          let obj;
+          try {
+            obj = JSON.parse(content);
+          } catch {
+            obj = null;
+          }
+          if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+            for (const [k, v] of Object.entries(obj)) {
+              if (k === "__drop" && Array.isArray(v)) {
+                for (const d of v)
+                  s.pending_renames.push({ drop: String(d) });
+              } else if (typeof v === "string")
+                s.pending_renames.push({ from: k, to: v });
+            }
+          }
+        }
+        if (/flags\.json/i.test(p)) {
+          for (const m of content.matchAll(/"(\w+)":\s*"optional"/g))
+            pushUniq(s.optional_fields_added, m[1]);
+          for (const m of content.matchAll(/"(\w+)":\s*"required"/g))
+            pushUniq(s.required_fields_declared, m[1]);
+        }
+        if (/optional_fields/i.test(p)) {
+          for (const line of content.split("\n"))
+            if (line.trim())
+              pushUniq(s.optional_fields_added, line.trim());
+        }
+        if (/required_fields/i.test(p)) {
+          for (const line of content.split("\n"))
+            if (line.trim())
+              pushUniq(s.required_fields_declared, line.trim());
+        }
+        if (NON_SSOT_RE.test(p) && /required:\s*\[[^\]]*owner_id/.test(content))
+          pushUniq(s.required_fields_declared, "owner_id");
+        if (NON_SSOT_RE.test(p) && /owner_id:\s*\{type: string\}/.test(content))
+          pushUniq(s.optional_fields_added, "owner_id");
+        if (/\.idl$/i.test(p) || p.startsWith("idl/"))
+          pushUniq(s.intermediate_artifacts, p);
+      }
+      if (/BREAKING_DROP|FIELD .* REMOVE|MANDATORY/i.test(content))
+        pushUniq(s.intermediate_artifacts, paths[0] || "inline_flag");
+      s.tainted = computeTainted(s);
+      return s;
+    }
+    function computeTainted(s) {
+      return s.contract_looking_scratch.length > 0 || s.encoded_fragments.length > 0 || s.intermediate_artifacts.length > 0 || s.store_keys.some((k) => /spec_|api_|schema|openapi/i.test(k)) || s.pending_renames.length > 0 || s.optional_fields_added.some((f) => s.required_fields_declared.includes(f)) || s.required_fields_declared.length > 0 && s.optional_fields_added.length > 0 || s.ssot_invalidated === true;
+    }
+    function deriveKeySignal(s) {
+      if (s.ssot_invalidated)
+        return "delete_recreate_ssot_via_session";
+      if (s.encoded_fragments.length)
+        return "encoded_scratch_then_ssot_promotion";
+      if (s.optional_fields_added.some((f) => s.required_fields_declared.includes(f)) || s.required_fields_declared.length && s.optional_fields_added.length)
+        return "cumulative_required_flip";
+      if (s.pending_renames.length)
+        return "cumulative_rename_via_codegen";
+      if (s.contract_looking_scratch.length)
+        return "scratch_to_ssot_promotion";
+      if (s.intermediate_artifacts.length)
+        return "cross_call_reassembly_to_ssot";
+      return "session_ssot_sink_with_taint";
+    }
+    function evaluate(state, prevFlagged = false, opts = {}) {
+      const sink = state.ssot_sink_events.length > 0 || opts.sinkSeen === true;
+      const taint = state.tainted || opts.overflow === true;
+      const flag = sink && taint;
+      return { flag, trip: flag && !prevFlagged, key_signal: flag ? deriveKeySignal(state) : null };
+    }
+    var DEF = { maxCalls: 256, maxPathsTracked: 512, maxSinkEvents: 64, maxStateBytes: 256e3, ttlMs: 36e5 };
+    var SessionTaintTracker = class {
+      version = exports2.SESSION_TAINT_VERSION;
+      state = emptySessionState();
+      prevFlag = false;
+      callCount = 0;
+      overflow = false;
+      sinkSeen = false;
+      lastObserveAt = 0;
+      cfg;
+      constructor(config = {}) {
+        this.cfg = config;
+      }
+      pathTotal() {
+        const s = this.state;
+        return s.scratch_writes.length + s.contract_looking_scratch.length + s.encoded_fragments.length + s.intermediate_artifacts.length + s.ssot_paths_touched.length;
+      }
+      observe(call) {
+        const now = this.now();
+        if (this.lastObserveAt && now - this.lastObserveAt > (this.cfg.ttlMs ?? DEF.ttlMs))
+          this.reset();
+        this.lastObserveAt = now;
+        const next = updateSession(this.state, call, this.cfg);
+        this.callCount++;
+        if (this.callCount > (this.cfg.maxCalls ?? DEF.maxCalls))
+          this.overflow = true;
+        if (this.pathTotal() > (this.cfg.maxPathsTracked ?? DEF.maxPathsTracked))
+          this.overflow = true;
+        if (JSON.stringify(next).length > (this.cfg.maxStateBytes ?? DEF.maxStateBytes))
+          this.overflow = true;
+        if (next.ssot_sink_events.length > (this.cfg.maxSinkEvents ?? DEF.maxSinkEvents)) {
+          next.ssot_sink_events = next.ssot_sink_events.slice(0, this.cfg.maxSinkEvents ?? DEF.maxSinkEvents);
+        }
+        this.state = next;
+        if (this.state.ssot_sink_events.length > 0)
+          this.sinkSeen = true;
+        return this.snapshot();
+      }
+      status() {
+        return this.snapshot();
+      }
+      reset() {
+        this.state = emptySessionState();
+        this.prevFlag = false;
+        this.callCount = 0;
+        this.overflow = false;
+        this.sinkSeen = false;
+        this.lastObserveAt = 0;
+      }
+      snapshot() {
+        const eva = evaluate(this.state, this.prevFlag, { overflow: this.overflow, sinkSeen: this.sinkSeen });
+        if (eva.flag)
+          this.prevFlag = true;
+        return {
+          flag: eva.flag,
+          trip: eva.trip,
+          key_signal: eva.key_signal,
+          state: projectState(this.state),
+          version: exports2.SESSION_TAINT_VERSION,
+          overflow: this.overflow,
+          severity: this.cfg.sessionTaintSeverity || "caution"
+        };
+      }
+      // Date.now is fine at runtime; isolated for testability.
+      now() {
+        return Date.now();
+      }
+    };
+    exports2.SessionTaintTracker = SessionTaintTracker;
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/resolver-yaml.js
+var require_resolver_yaml = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/resolver-yaml.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.YamlLiteError = void 0;
+    exports2.parseDoc = parseDoc;
+    exports2.stableStringify = stableStringify;
+    var YamlLiteError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "YamlLiteError";
+      }
+    };
+    exports2.YamlLiteError = YamlLiteError;
+    function parseDoc(text) {
+      const trimmed = text.trimStart();
+      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+          return JSON.parse(text);
+        } catch (e) {
+          throw new YamlLiteError(`invalid JSON: ${e.message}`);
+        }
+      }
+      const lines = [];
+      for (const raw of text.split("\n")) {
+        const trimmedLine = raw.trim();
+        if (trimmedLine === "" || trimmedLine.startsWith("#"))
+          continue;
+        lines.push({ indent: raw.length - raw.trimStart().length, text: trimmedLine });
+      }
+      if (lines.length === 0)
+        return null;
+      const [value] = parseBlock(lines, 0, lines[0].indent);
+      return value;
+    }
+    function parseBlock(lines, start, indent) {
+      if (start >= lines.length)
+        return [null, start];
+      const first = lines[start];
+      if (first.text === "-" || first.text.startsWith("- "))
+        return parseSequence(lines, start, indent);
+      return parseMapping(lines, start, indent);
+    }
+    function parseMapping(lines, start, indent) {
+      const obj = {};
+      let i = start;
+      while (i < lines.length && lines[i].indent === indent) {
+        const { key, rest } = splitKeyValue(lines[i].text);
+        i += 1;
+        if (rest === "") {
+          if (i < lines.length && lines[i].indent > indent) {
+            const [child, next] = parseBlock(lines, i, lines[i].indent);
+            obj[key] = child;
+            i = next;
+          } else {
+            obj[key] = null;
+          }
+        } else {
+          obj[key] = parseScalarOrFlow(rest);
+        }
+      }
+      return [obj, i];
+    }
+    function parseSequence(lines, start, indent) {
+      const arr = [];
+      let i = start;
+      while (i < lines.length && lines[i].indent === indent && (lines[i].text === "-" || lines[i].text.startsWith("- "))) {
+        const itemText = lines[i].text.slice(1).trim();
+        i += 1;
+        if (itemText === "") {
+          if (i < lines.length && lines[i].indent > indent) {
+            const [child, next] = parseBlock(lines, i, lines[i].indent);
+            arr.push(child);
+            i = next;
+          } else {
+            arr.push(null);
+          }
+        } else {
+          arr.push(parseScalarOrFlow(itemText));
+        }
+      }
+      return [arr, i];
+    }
+    function splitKeyValue(text) {
+      let key;
+      let idx;
+      if (text[0] === "'" || text[0] === '"') {
+        const q = text[0];
+        let j = 1;
+        while (j < text.length && text[j] !== q)
+          j += 1;
+        key = text.slice(1, j);
+        idx = text.indexOf(":", j);
+      } else {
+        idx = text.indexOf(":");
+        key = idx === -1 ? text : text.slice(0, idx);
+      }
+      if (idx === -1)
+        return { key: key.trim(), rest: "" };
+      return { key: key.trim(), rest: text.slice(idx + 1).trim() };
+    }
+    function parseScalarOrFlow(s) {
+      const t = s.trim();
+      if (t === "" || t === "~" || t === "null")
+        return null;
+      if (t[0] === "{" || t[0] === "[")
+        return parseFlow(t).value;
+      if (t[0] === "'" || t[0] === '"')
+        return unquote(t);
+      return t;
+    }
+    function unquote(t) {
+      const q = t[0];
+      let j = 1;
+      let out = "";
+      while (j < t.length && t[j] !== q) {
+        out += t[j];
+        j += 1;
+      }
+      return out;
+    }
+    function parseFlow(s) {
+      if (s[0] === "{")
+        return parseFlowMap(s);
+      if (s[0] === "[")
+        return parseFlowSeq(s);
+      throw new YamlLiteError(`not a flow collection: ${s.slice(0, 20)}`);
+    }
+    function parseFlowMap(s) {
+      const obj = {};
+      let i = 1;
+      while (i < s.length) {
+        while (i < s.length && (s[i] === " " || s[i] === ","))
+          i += 1;
+        if (s[i] === "}")
+          return { value: obj, end: i + 1 };
+        let key;
+        if (s[i] === "'" || s[i] === '"') {
+          const q = s[i];
+          let j = i + 1;
+          let k = "";
+          while (j < s.length && s[j] !== q) {
+            k += s[j];
+            j += 1;
+          }
+          key = k;
+          i = j + 1;
+        } else {
+          let k = "";
+          while (i < s.length && s[i] !== ":" && s[i] !== "}" && s[i] !== ",") {
+            k += s[i];
+            i += 1;
+          }
+          key = k.trim();
+        }
+        while (i < s.length && (s[i] === " " || s[i] === ":"))
+          i += 1;
+        const [val, next] = readFlowValue(s, i);
+        obj[key] = val;
+        i = next;
+      }
+      throw new YamlLiteError(`unterminated flow map: ${s.slice(0, 40)}`);
+    }
+    function parseFlowSeq(s) {
+      const arr = [];
+      let i = 1;
+      while (i < s.length) {
+        while (i < s.length && (s[i] === " " || s[i] === ","))
+          i += 1;
+        if (s[i] === "]")
+          return { value: arr, end: i + 1 };
+        const [val, next] = readFlowValue(s, i);
+        arr.push(val);
+        i = next;
+      }
+      throw new YamlLiteError(`unterminated flow seq: ${s.slice(0, 40)}`);
+    }
+    function readFlowValue(s, start) {
+      let i = start;
+      while (i < s.length && s[i] === " ")
+        i += 1;
+      if (s[i] === "{" || s[i] === "[") {
+        const { value, end } = parseFlow(s.slice(i));
+        return [value, i + end];
+      }
+      if (s[i] === "'" || s[i] === '"') {
+        const q = s[i];
+        let j = i + 1;
+        let out2 = "";
+        while (j < s.length && s[j] !== q) {
+          out2 += s[j];
+          j += 1;
+        }
+        return [out2, j + 1];
+      }
+      let out = "";
+      while (i < s.length && s[i] !== "," && s[i] !== "}" && s[i] !== "]") {
+        out += s[i];
+        i += 1;
+      }
+      return [out.trim(), i];
+    }
+    function stableStringify(value) {
+      return JSON.stringify(sortKeys(value));
+    }
+    function sortKeys(value) {
+      if (Array.isArray(value))
+        return value.map(sortKeys);
+      if (value && typeof value === "object") {
+        const out = {};
+        for (const k of Object.keys(value).sort()) {
+          out[k] = sortKeys(value[k]);
+        }
+        return out;
+      }
+      return value;
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/resolver-glob.js
+var require_resolver_glob = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/resolver-glob.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.globToRegExp = globToRegExp;
+    exports2.matchGlob = matchGlob;
+    exports2.matchAny = matchAny;
+    exports2.firstMatchIndex = firstMatchIndex;
+    function globToRegExp(glob) {
+      let re = "";
+      for (let i = 0; i < glob.length; i += 1) {
+        const c = glob[i];
+        if (c === "*") {
+          if (glob[i + 1] === "*") {
+            i += 1;
+            if (glob[i + 1] === "/") {
+              re += "(?:.*/)?";
+              i += 1;
+            } else {
+              re += ".*";
+            }
+          } else {
+            re += "[^/]*";
+          }
+        } else if (c === "?") {
+          re += "[^/]";
+        } else if (".+^${}()|[]\\".includes(c)) {
+          re += `\\${c}`;
+        } else {
+          re += c;
+        }
+      }
+      return new RegExp(`^${re}$`);
+    }
+    function matchGlob(glob, path) {
+      return globToRegExp(glob).test(path);
+    }
+    function matchAny(globs, path) {
+      if (!Array.isArray(globs))
+        return false;
+      return globs.some((g) => g === path || matchGlob(g, path));
+    }
+    function firstMatchIndex(globs, path) {
+      if (!Array.isArray(globs))
+        return -1;
+      for (let i = 0; i < globs.length; i += 1) {
+        if (globs[i] === path || matchGlob(globs[i], path))
+          return i;
+      }
+      return -1;
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/artifact-resolver.js
+var require_artifact_resolver = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/artifact-resolver.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolve = resolve;
+    var resolver_yaml_js_1 = require_resolver_yaml();
+    var resolver_glob_js_1 = require_resolver_glob();
+    var DEFAULT_GENERATED = ["**/generated/**", "**/gen/**"];
+    var VENDOR_GLOBS = ["**/node_modules/**", "**/vendor/**"];
+    function normalizePath(p) {
+      let s = p.replace(/\\/g, "/").trim();
+      while (s.startsWith("./"))
+        s = s.slice(2);
+      return s;
+    }
+    function dirname(p) {
+      const i = p.lastIndexOf("/");
+      return i === -1 ? "" : p.slice(0, i);
+    }
+    function basename(p) {
+      const i = p.lastIndexOf("/");
+      return i === -1 ? p : p.slice(i + 1);
+    }
+    function extname(p) {
+      const b = basename(p);
+      const i = b.lastIndexOf(".");
+      return i === -1 ? "" : b.slice(i + 1).toLowerCase();
+    }
+    function resolveRelative(dir, rel) {
+      const parts = (dir ? dir.split("/") : []).concat(normalizePath(rel).split("/"));
+      const out = [];
+      for (const seg of parts) {
+        if (seg === "" || seg === ".")
+          continue;
+        if (seg === "..")
+          out.pop();
+        else
+          out.push(seg);
+      }
+      return out.join("/");
+    }
+    function classifyByName(path) {
+      const b = basename(path).toLowerCase();
+      const ext = extname(path);
+      const yamlJson = ext === "yaml" || ext === "yml" || ext === "json";
+      if (yamlJson && (b.includes("openapi") || b.includes("swagger")))
+        return "openapi";
+      if (yamlJson && b.includes("asyncapi"))
+        return "asyncapi";
+      if (ext === "graphql" || ext === "gql")
+        return "graphql";
+      if (ext === "proto")
+        return "grpc";
+      if (b === "mcp.json" || b === "tools-catalog.json")
+        return "mcp_manifest";
+      return null;
+    }
+    function classifyByContent(text) {
+      if (!text)
+        return null;
+      if (/(^|\n)\s*["']?openapi["']?\s*:\s*["']?[23]/.test(text) || /swagger\s*:/.test(text) && /paths\s*:/.test(text))
+        return "openapi";
+      if (/(^|\n)\s*["']?asyncapi["']?\s*:/.test(text))
+        return "asyncapi";
+      if (/\btype\s+Query\b|\btype\s+Mutation\b|\bschema\s*\{/.test(text))
+        return "graphql";
+      if (/syntax\s*=\s*["']proto[23]["']/.test(text))
+        return "grpc";
+      try {
+        const j = JSON.parse(text);
+        if (j && Array.isArray(j.tools) && j.tools.some((t) => t && typeof t === "object" && "inputSchema" in t))
+          return "mcp_manifest";
+      } catch {
+      }
+      return null;
+    }
+    function isMcpByNameNeedingContent(path) {
+      const b = basename(path).toLowerCase();
+      return extname(path) === "json" && b.includes("mcp") && b !== "mcp.json";
+    }
+    var REF_RE = /\$ref["']?\s*:\s*["']?([^"'\s,}]+)["']?/g;
+    function scanRefs(text) {
+      const out = [];
+      let m;
+      REF_RE.lastIndex = 0;
+      while ((m = REF_RE.exec(text)) !== null)
+        out.push(m[1]);
+      return out;
+    }
+    function isExternalRef(ref) {
+      return /^[a-z][a-z0-9+.-]*:\/\//i.test(ref) || ref.startsWith("//");
+    }
+    function isInternalRef(ref) {
+      return ref.startsWith("#");
+    }
+    function splitRef(ref) {
+      const i = ref.indexOf("#");
+      return i === -1 ? { file: ref, pointer: "" } : { file: ref.slice(0, i), pointer: ref.slice(i + 1) };
+    }
+    function jsonPointer(doc, pointer) {
+      if (pointer === "" || pointer === "/")
+        return doc;
+      const parts = pointer.replace(/^\//, "").split("/").map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+      let cur = doc;
+      for (const part of parts) {
+        if (cur && typeof cur === "object" && part in cur)
+          cur = cur[part];
+        else
+          return void 0;
+      }
+      return cur;
+    }
+    function slugify(s) {
+      return s.replace(/[^A-Za-z0-9]+/g, "_");
+    }
+    var RefError = class extends Error {
+      reason;
+      related;
+      constructor(reason, related) {
+        super(reason);
+        this.reason = reason;
+        this.related = related;
+      }
+    };
+    function assembleSide(rootPath, rootText, refSide, input, config, deps) {
+      const maxDepth = config.maxRefDepth ?? 8;
+      let root;
+      try {
+        root = (0, resolver_yaml_js_1.parseDoc)(rootText);
+      } catch (e) {
+        if (e instanceof resolver_yaml_js_1.YamlLiteError)
+          throw new RefError("parse_error");
+        throw e;
+      }
+      const components = {};
+      const inline = (node, curDir, depth, stack) => {
+        if (Array.isArray(node))
+          return node.map((n) => inline(n, curDir, depth, stack));
+        if (node && typeof node === "object") {
+          const rec = node;
+          if (typeof rec.$ref === "string") {
+            const ref = rec.$ref;
+            if (isExternalRef(ref))
+              throw new RefError("external_ref_forbidden");
+            if (isInternalRef(ref))
+              return { ...rec };
+            const { file, pointer } = splitRef(ref);
+            const targetPath = resolveRelative(curDir, file);
+            const key = `${targetPath}#${pointer}`;
+            if (depth + 1 > maxDepth)
+              throw new RefError("ref_depth_exceeded", targetPath);
+            if (stack.has(key))
+              throw new RefError("ref_cycle", targetPath);
+            const blob = getBlob(input, refSide, targetPath);
+            if (blob === null || blob === void 0)
+              throw new RefError("missing_ref_target", targetPath);
+            if (typeof blob === "object")
+              throw new RefError(blob.error, targetPath);
+            deps.add(targetPath);
+            let targetDoc;
+            try {
+              targetDoc = (0, resolver_yaml_js_1.parseDoc)(blob);
+            } catch {
+              throw new RefError("parse_error", targetPath);
+            }
+            const resolved = jsonPointer(targetDoc, pointer);
+            if (resolved === void 0)
+              throw new RefError("missing_ref_target", targetPath);
+            const inlined = inline(resolved, dirname(targetPath), depth + 1, /* @__PURE__ */ new Set([...stack, key]));
+            const slug = slugify(`${targetPath}__${pointer}`);
+            components[slug] = inlined;
+            return { $ref: `#/components/${slug}` };
+          }
+          const out = {};
+          for (const k of Object.keys(rec))
+            out[k] = inline(rec[k], curDir, depth, stack);
+          return out;
+        }
+        return node;
+      };
+      const inlinedRoot = inline(root, dirname(rootPath), 0, /* @__PURE__ */ new Set());
+      if (Object.keys(components).length > 0) {
+        const existing = inlinedRoot.components && typeof inlinedRoot.components === "object" ? inlinedRoot.components : {};
+        inlinedRoot.components = { ...existing, ...components };
+      }
+      return (0, resolver_yaml_js_1.stableStringify)(inlinedRoot);
+    }
+    function getBlob(input, ref, path) {
+      return input.blobs[`${ref}:${path}`];
+    }
+    function loadRoot(path, type, input, config) {
+      const baseBlob = getBlob(input, input.baseRef, path);
+      const headBlob = getBlob(input, input.headRef, path);
+      if (baseBlob && typeof baseBlob === "object")
+        return { unresolved: { path, reason: baseBlob.error } };
+      if (headBlob && typeof headBlob === "object")
+        return { unresolved: { path, reason: headBlob.error } };
+      const baseNull = baseBlob === null || baseBlob === void 0;
+      const headNull = headBlob === null || headBlob === void 0;
+      if (baseNull && headNull)
+        return { unresolved: { path, reason: "empty_changed_contract" } };
+      let before = baseNull ? "" : baseBlob;
+      let after = headNull ? "" : headBlob;
+      const deps = /* @__PURE__ */ new Set();
+      const assemble = (type === "openapi" || type === "asyncapi") && (config.openApiAssembly ?? "bundle_inline") === "bundle_inline";
+      if (assemble) {
+        try {
+          if (before !== "" && scanRefs(before).some((r) => !isInternalRef(r)))
+            before = assembleSide(path, before, input.baseRef, input, config, deps);
+          if (after !== "" && scanRefs(after).some((r) => !isInternalRef(r)))
+            after = assembleSide(path, after, input.headRef, input, config, deps);
+        } catch (e) {
+          if (e instanceof RefError)
+            return { unresolved: { path, reason: e.reason, ...e.related ? { related_paths: [e.related] } : {} } };
+          throw e;
+        }
+      }
+      const id = input.repository ? `${input.repository}:${type}:${path}` : `${type}:${path}`;
+      return { artifact: { id, type, before, after }, deps: [...deps] };
+    }
+    function selectGroups(candidates, config, generatedGlobs) {
+      const n = candidates.length;
+      const parent = Array.from({ length: n }, (_, i) => i);
+      const find = (x) => {
+        while (parent[x] !== x) {
+          parent[x] = parent[parent[x]];
+          x = parent[x];
+        }
+        return x;
+      };
+      const union = (a, b) => {
+        const ra = find(a);
+        const rb = find(b);
+        if (ra !== rb)
+          parent[Math.max(ra, rb)] = Math.min(ra, rb);
+      };
+      if (Array.isArray(config.forceSameSurfaceGroup)) {
+        const idxs = candidates.map((c, i) => config.forceSameSurfaceGroup.includes(c.path) ? i : -1).filter((i) => i >= 0);
+        for (let k = 1; k < idxs.length; k += 1)
+          union(idxs[0], idxs[k]);
+      }
+      const byType = /* @__PURE__ */ new Map();
+      candidates.forEach((c, i) => {
+        const a = byType.get(c.type) ?? [];
+        a.push(i);
+        byType.set(c.type, a);
+      });
+      for (const idxs of byType.values()) {
+        const gen = idxs.filter((i) => (0, resolver_glob_js_1.matchAny)(generatedGlobs, candidates[i].path));
+        if (gen.length > 0 && gen.length < idxs.length)
+          for (let k = 1; k < idxs.length; k += 1)
+            union(idxs[0], idxs[k]);
+      }
+      const groups = /* @__PURE__ */ new Map();
+      for (let i = 0; i < n; i += 1) {
+        const r = find(i);
+        const g = groups.get(r) ?? [];
+        g.push(i);
+        groups.set(r, g);
+      }
+      const selections = [];
+      const chosen = [];
+      const ambiguous = [];
+      for (const g of groups.values()) {
+        const members = g.map((i) => candidates[i].path).sort();
+        if (members.length === 1) {
+          chosen.push(candidates[g[0]]);
+          selections.push({ chosen: members[0], deferred: [], reason: "single" });
+          continue;
+        }
+        const prefRanked = members.map((p) => ({ p, rank: (0, resolver_glob_js_1.firstMatchIndex)(config.ssotPrefer, p) })).filter((x) => x.rank >= 0);
+        if (prefRanked.length > 0) {
+          prefRanked.sort((a, b) => a.rank - b.rank || (a.p < b.p ? -1 : 1));
+          const chosenPath = prefRanked[0].p;
+          chosen.push(candidates[g.find((i) => candidates[i].path === chosenPath)]);
+          selections.push({ chosen: chosenPath, deferred: members.filter((m) => m !== chosenPath), reason: "ssotPrefer" });
+          continue;
+        }
+        const nongen = members.filter((p) => !(0, resolver_glob_js_1.matchAny)(generatedGlobs, p));
+        if (nongen.length === 1) {
+          const chosenPath = nongen[0];
+          chosen.push(candidates[g.find((i) => candidates[i].path === chosenPath)]);
+          selections.push({ chosen: chosenPath, deferred: members.filter((m) => m !== chosenPath), reason: "generated_deprioritized" });
+          continue;
+        }
+        ambiguous.push(...members);
+      }
+      return { selections, chosen, ambiguous };
+    }
+    function resolve(input, config = {}) {
+      const generatedGlobs = config.generatedGlobs ?? DEFAULT_GENERATED;
+      const seen = /* @__PURE__ */ new Set();
+      const paths = [];
+      for (const raw of Array.isArray(input.changedFiles) ? input.changedFiles : []) {
+        const p = normalizePath(raw);
+        if (p && !seen.has(p)) {
+          seen.add(p);
+          paths.push(p);
+        }
+      }
+      const candidates = [];
+      const ignored = [];
+      for (const p of paths) {
+        if ((0, resolver_glob_js_1.matchAny)(VENDOR_GLOBS, p)) {
+          ignored.push(p);
+          continue;
+        }
+        let type = config.pathTypeHints?.[p] ?? classifyByName(p);
+        if (type === null || isMcpByNameNeedingContent(p)) {
+          const peek = firstDefinedText(getBlob(input, input.headRef, p), getBlob(input, input.baseRef, p));
+          const sniff = classifyByContent(peek);
+          if (isMcpByNameNeedingContent(p))
+            type = sniff === "mcp_manifest" ? "mcp_manifest" : type ?? sniff;
+          else
+            type = sniff;
+        }
+        if (type)
+          candidates.push({ path: p, type });
+        else
+          ignored.push(p);
+      }
+      const unresolved = [];
+      let effectiveCandidates = candidates;
+      if (config.requireSsotIfConfigured && Array.isArray(config.ssotPrefer)) {
+        const missing = config.ssotPrefer.filter((pref) => !hasGlobChar(pref) && !existsInTree(input, pref));
+        const hasGenerated = candidates.some((c) => (0, resolver_glob_js_1.matchAny)(generatedGlobs, c.path));
+        if (missing.length > 0 && hasGenerated) {
+          for (const pref of missing)
+            unresolved.push({ path: pref, reason: "config_ssot_missing" });
+          effectiveCandidates = candidates.filter((c) => !(0, resolver_glob_js_1.matchAny)(generatedGlobs, c.path));
+        }
+      }
+      const { selections, chosen, ambiguous } = selectGroups(effectiveCandidates, config, generatedGlobs);
+      for (const p of [...new Set(ambiguous)].sort())
+        unresolved.push({ path: p, reason: "ambiguous_ssot" });
+      const artifacts = [];
+      const selBySel = new Map(selections.map((s) => [s.chosen, s]));
+      for (const c of chosen.slice().sort((a, b) => a.path < b.path ? -1 : 1)) {
+        const res = loadRoot(c.path, c.type, input, config);
+        if ("artifact" in res) {
+          artifacts.push(res.artifact);
+          const sel = selBySel.get(c.path);
+          for (const dep of res.deps) {
+            const idx = ignored.indexOf(dep);
+            if (idx >= 0)
+              ignored.splice(idx, 1);
+            if (sel && !sel.deferred.includes(dep) && dep !== c.path)
+              sel.deferred.push(dep);
+          }
+          if (sel)
+            sel.deferred.sort();
+        } else {
+          unresolved.push(res.unresolved);
+        }
+      }
+      const A = artifacts.length;
+      const U = unresolved.length;
+      const chosenCount = chosen.length;
+      let coverage;
+      if (chosenCount === 0 && U === 0)
+        coverage = "EMPTY";
+      else if (U === 0 && A >= 1 && A === chosenCount)
+        coverage = "COMPLETE";
+      else if (A >= 1 && U >= 1)
+        coverage = "PARTIAL";
+      else
+        coverage = "UNRESOLVED";
+      artifacts.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+      unresolved.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.reason < b.reason ? -1 : a.reason > b.reason ? 1 : 0);
+      ignored.sort();
+      const contractDiscovered = effectiveCandidates.map((c) => c.path).slice().sort();
+      return {
+        artifacts,
+        unresolved,
+        coverage,
+        report: {
+          version: "artifact-resolver-report/1.0",
+          baseRef: input.baseRef,
+          headRef: input.headRef,
+          contract_paths_discovered: contractDiscovered,
+          ignored_non_contract: ignored,
+          ssot_selections: selections,
+          claim: {
+            artifacts_ready_for_preflight: coverage === "COMPLETE" || coverage === "EMPTY",
+            produces_verdict: false
+          }
+        }
+      };
+    }
+    function firstDefinedText(...vals) {
+      for (const v of vals)
+        if (typeof v === "string")
+          return v;
+      return void 0;
+    }
+    function hasGlobChar(p) {
+      return /[*?]/.test(p);
+    }
+    function existsInTree(input, path) {
+      return typeof getBlob(input, input.baseRef, path) === "string" || typeof getBlob(input, input.headRef, path) === "string";
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/tool-registry.js
+var require_tool_registry = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/tool-registry.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.RegistryConstructionError = void 0;
+    exports2.guardToolRegistry = guardToolRegistry;
+    var guard_js_1 = require_guard();
+    var RegistryConstructionError = class extends Error {
+      code;
+      toolName;
+      constructor(code, message, toolName) {
+        super(message);
+        this.name = "RegistryConstructionError";
+        this.code = code;
+        this.toolName = toolName;
+      }
+    };
+    exports2.RegistryConstructionError = RegistryConstructionError;
+    var MUTATING_GENERIC = ["write", "edit", "create", "update", "delete", "remove", "apply_patch", "applypatch", "str_replace", "notebook_edit", "multi_edit", "insert"];
+    var MUTATING_SHELL = ["bash", "shell", "terminal", "run_command", "exec", "powershell"];
+    var MUTATING_VCS = ["git_commit", "git_push", "git_merge", "commit", "push"];
+    var MUTATING_DEPLOY = ["deploy", "kubectl_apply", "helm_upgrade", "release"];
+    var MUTATING_PUBLISH = ["npm_publish", "publish_package", "twine_upload", "cargo_publish"];
+    var MUTATING_SCHEMA = ["register_tools", "update_manifest", "mcp_register"];
+    var READONLY = ["read", "grep", "glob", "search", "list", "ls", "cat", "get", "fetch", "web_search", "browser_navigate"];
+    function isMutatingClass(cls) {
+      return cls !== "readonly";
+    }
+    function matchesAny(hay, patterns) {
+      return patterns.some((p) => hay.includes(p));
+    }
+    function heuristicClass(name) {
+      const n = String(name || "").toLowerCase();
+      if (matchesAny(n, MUTATING_SHELL))
+        return "mutating_shell";
+      if (matchesAny(n, MUTATING_VCS) || n.startsWith("git_"))
+        return "mutating_vcs";
+      if (matchesAny(n, MUTATING_DEPLOY))
+        return "mutating_deploy";
+      if (matchesAny(n, MUTATING_PUBLISH))
+        return "mutating_publish";
+      if (matchesAny(n, MUTATING_SCHEMA))
+        return "mutating_schema";
+      if (matchesAny(n, MUTATING_GENERIC))
+        return "mutating";
+      if (matchesAny(n, READONLY))
+        return "readonly";
+      return null;
+    }
+    function resolveClass(tool, config, unknownPolicy) {
+      const classify = config.classify || {};
+      if (Object.prototype.hasOwnProperty.call(classify, tool.name))
+        return { cls: classify[tool.name], source: "classify" };
+      if (tool.mutationClass)
+        return { cls: tool.mutationClass, source: "mutationClass" };
+      if (Array.isArray(config.forceReadonly) && config.forceReadonly.includes(tool.name))
+        return { cls: "readonly", source: "forceReadonly" };
+      const h = heuristicClass(tool.name);
+      if (h)
+        return { cls: h, source: "heuristic" };
+      if (unknownPolicy === "reject") {
+        throw new RegistryConstructionError("UNKNOWN_TOOL", `tool '${tool.name}' is unclassified and unknownToolPolicy='reject'`, tool.name);
+      }
+      return { cls: unknownPolicy === "readonly" ? "readonly" : "mutating", source: "unknown" };
+    }
+    function operationForClass(cls, name, guardOperation) {
+      switch (cls) {
+        case "mutating_shell":
+          return "tool_call";
+        case "mutating_vcs":
+          return /merge/i.test(name) ? "merge" : "tool_call";
+        case "mutating_deploy":
+          return "deploy";
+        case "mutating_publish":
+          return "publish";
+        case "mutating_schema":
+          return "tool_call";
+        case "mutating":
+        default:
+          return guardOperation ?? "tool_call";
+      }
+    }
+    function defaultBinder(tool, args) {
+      return { toolName: tool.name, arguments: args };
+    }
+    var RAW_EXECUTORS = /* @__PURE__ */ new WeakMap();
+    function freezeTool(t) {
+      Object.freeze(t._coderifts);
+      return Object.freeze(t);
+    }
+    function passthroughProtected(tool, cls) {
+      const rawExecute = tool.execute;
+      const protectedTool = {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        meta: tool.meta,
+        execute: async (args) => rawExecute(args),
+        // new function, not === rawExecute
+        _coderifts: { guarded: false, mutationClass: cls }
+      };
+      RAW_EXECUTORS.set(protectedTool, rawExecute);
+      return freezeTool(protectedTool);
+    }
+    function wrapWithGuard(tool, cls, config) {
+      const rawExecute = tool.execute;
+      const guardBase = config.guard;
+      const operation = operationForClass(cls, tool.name, guardBase.operation);
+      const guardCfg = { ...guardBase, operation };
+      const binder = config.binders && config.binders[tool.name] || ((t, a) => defaultBinder(t, a));
+      const protectedTool = {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        meta: tool.meta,
+        execute: async (args) => {
+          const call = binder(tool, args, cls);
+          return (0, guard_js_1.guardToolCall)(call, async (_envelope, redacted) => rawExecute(redacted ? redacted.arguments : args), guardCfg);
+        },
+        _coderifts: { guarded: true, mutationClass: cls, operation }
+      };
+      RAW_EXECUTORS.set(protectedTool, rawExecute);
+      return freezeTool(protectedTool);
+    }
+    function guardToolRegistry(rawTools, config = {}) {
+      const failHard = config.failOnUnguardedMutator !== false;
+      const unknownPolicy = config.unknownToolPolicy ?? "mutating";
+      const input = Array.isArray(rawTools) ? rawTools : [];
+      for (const tool of input) {
+        if (!tool || typeof tool.name !== "string" || tool.name.trim() === "") {
+          throw new RegistryConstructionError("INVALID_TOOL", "a tool has a missing or empty name");
+        }
+        if (typeof tool.execute !== "function") {
+          throw new RegistryConstructionError("INVALID_TOOL", `tool '${tool.name}' has no execute function`, tool.name);
+        }
+      }
+      const seen = /* @__PURE__ */ new Set();
+      for (const tool of input) {
+        if (seen.has(tool.name)) {
+          throw new RegistryConstructionError("DUPLICATE_TOOL_NAME", `duplicate tool name '${tool.name}'`, tool.name);
+        }
+        seen.add(tool.name);
+      }
+      const sorted = input.slice().sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+      const guardedMutators = [];
+      const readonlyPassthrough = [];
+      const warnings = [];
+      const staged = [];
+      let anyForced = false;
+      let anyUnknownReadonly = false;
+      for (const tool of sorted) {
+        const { cls, source } = resolveClass(tool, config, unknownPolicy);
+        const forced = cls === "readonly" && (source === "classify" || source === "forceReadonly") && isMutating(heuristicClass(tool.name));
+        if (forced) {
+          anyForced = true;
+          warnings.push(`force_readonly_on_mutator_heuristic:${tool.name}`);
+        }
+        if (source === "unknown" && cls === "readonly")
+          anyUnknownReadonly = true;
+        staged.push({ tool, cls, forced });
+      }
+      if (anyForced && failHard) {
+        throw new RegistryConstructionError("FORCE_READONLY_MUTATOR", `forceReadonly/classify downgraded a heuristic mutator to readonly while failOnUnguardedMutator is true`);
+      }
+      const willWrap = staged.some((s) => isMutating(s.cls) && !s.forced);
+      const validGuard = !!(config.guard && config.guard.client);
+      if (willWrap && !validGuard) {
+        throw new RegistryConstructionError("GUARD_CONFIG_INVALID", "a mutating tool is present but config.guard.client is missing/invalid");
+      }
+      const protectedTools = [];
+      for (const { tool, cls, forced } of staged) {
+        if (cls === "readonly") {
+          readonlyPassthrough.push(tool.name);
+          protectedTools.push(passthroughProtected(tool, "readonly"));
+        } else {
+          guardedMutators.push(tool.name);
+          protectedTools.push(wrapWithGuard(tool, cls, config));
+        }
+        void forced;
+      }
+      for (const p of protectedTools) {
+        if (isMutatingClass(p._coderifts.mutationClass) && p._coderifts.guarded !== true) {
+          throw new RegistryConstructionError("GUARD_CONFIG_INVALID", `invariant violated: '${p.name}' is a mutator exposed without a guard`, p.name);
+        }
+      }
+      const M = guardedMutators.length;
+      const G = guardedMutators.length;
+      let coverage;
+      if (anyForced) {
+        coverage = "BYPASSED";
+      } else if (unknownPolicy === "readonly" && anyUnknownReadonly) {
+        coverage = "PARTIAL";
+      } else if (M === G) {
+        coverage = "COMPLETE";
+      } else {
+        coverage = "PARTIAL";
+      }
+      if (unknownPolicy === "readonly" && anyUnknownReadonly && !warnings.includes("unknown_treated_as_readonly")) {
+        warnings.push("unknown_treated_as_readonly");
+      }
+      const inescapableRuntime = coverage === "COMPLETE" && failHard;
+      const report = {
+        version: "guard-tool-registry-report/1.0",
+        coverage,
+        protected_tools: protectedTools.map((p) => p.name),
+        guarded_mutators: guardedMutators.slice(),
+        readonly_passthrough: readonlyPassthrough.slice(),
+        unguarded_mutators: [],
+        // strict impl: always [] (COMPLETE ⇒ [] by G4; forced tools are readonly)
+        unknown_treated_as: unknownPolicy,
+        claim: {
+          inescapable_runtime: inescapableRuntime,
+          inescapable_merge: false,
+          inescapable_deploy: false
+        },
+        siblings: {
+          merge_gate: "required_separate_#7",
+          artifact_resolver: "sibling_#4"
+        },
+        warnings
+      };
+      Object.freeze(report.claim);
+      Object.freeze(report.siblings);
+      Object.freeze(report);
+      return {
+        tools: Object.freeze(protectedTools),
+        coverage,
+        report
+      };
+    }
+    function isMutating(cls) {
+      return cls != null && cls !== "readonly";
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/merge-gate.js
+var require_merge_gate = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/merge-gate.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.gateDecision = gateDecision;
+    function normSha(s) {
+      return String(s == null ? "" : s).trim().toLowerCase();
+    }
+    function normOp(o) {
+      return String(o == null ? "" : o).trim().toLowerCase();
+    }
+    function sameHead(a, b, allowPrefix) {
+      const na = normSha(a);
+      const nb = normSha(b);
+      if (!na || !nb)
+        return false;
+      if (na === nb)
+        return true;
+      if (allowPrefix && na.length >= 7 && nb.length >= 7 && (na.startsWith(nb) || nb.startsWith(na)))
+        return true;
+      return false;
+    }
+    function isAllowClass(receipt, allowWarnMerge) {
+      const dec = receipt.decision;
+      const decisionOk = dec === "ALLOW" || dec === "WARN" && allowWarnMerge === true;
+      if (!decisionOk)
+        return false;
+      const ea = receipt.execution_action;
+      if (ea === void 0 || ea === null || ea === "")
+        return true;
+      return ea === "CONTINUE" || ea === "CONTINUE_WITH_MONITORING";
+    }
+    function targetMatches(targetId, repository) {
+      const t = String(targetId).toLowerCase();
+      const r = String(repository).toLowerCase();
+      return t === r || t === `repo:${r}` || t.endsWith(`:${r}`) || t.endsWith(`/${r}`);
+    }
+    function gateDecision(input) {
+      const rc = input.requiredContext || {};
+      const protection = rc.protection || { enforcement: "UNKNOWN", admin_bypass_possible: true };
+      const enforcement_state = protection.enforcement;
+      const allowPending = input.allowPending ?? rc.allowPending ?? false;
+      const allowWarnMerge = input.allowWarnMerge ?? rc.allowWarnMerge ?? false;
+      const allowPrefix = input.allowPrefixCompare ?? rc.allowPrefixCompare ?? false;
+      const receipt = input.receipt;
+      const detail = {
+        prHeadSha: normSha(input.prHeadSha),
+        bound_head_sha: receipt ? normSha(receipt.bound_head_sha) : null,
+        decision: receipt ? String(receipt.decision) : null
+      };
+      const fail = (state, reason) => ({
+        merge_allowed: false,
+        state,
+        reason,
+        enforcement_state,
+        inescapable_merge: false,
+        detail
+      });
+      if (!input.prHeadSha || String(input.prHeadSha).trim() === "") {
+        return fail(allowPending ? "pending" : "failure", "inputs_incomplete");
+      }
+      if (receipt === null || receipt === void 0) {
+        return fail(allowPending ? "pending" : "failure", "no_receipt");
+      }
+      if (receipt.currently_authorized !== true) {
+        return fail("failure", "receipt_not_authorized");
+      }
+      const op = rc.operation ?? "merge";
+      if (receipt.operation == null || normOp(receipt.operation) !== normOp(op)) {
+        return fail("failure", "operation_mismatch");
+      }
+      if (!sameHead(receipt.bound_head_sha, input.prHeadSha, allowPrefix)) {
+        return fail("failure", "stale_head");
+      }
+      if (rc.expected_fingerprint != null && receipt.verdict_fingerprint !== rc.expected_fingerprint) {
+        return fail("failure", "fingerprint_mismatch");
+      }
+      if (rc.expected_body_hash != null && receipt.body_hash !== rc.expected_body_hash) {
+        return fail("failure", "body_hash_mismatch");
+      }
+      if (rc.repository && receipt.target_id && !targetMatches(receipt.target_id, rc.repository)) {
+        return fail("failure", "target_mismatch");
+      }
+      if (!isAllowClass(receipt, allowWarnMerge)) {
+        return fail("failure", "decision_not_allow");
+      }
+      const inescapable_merge = enforcement_state === "ENFORCING" && protection.admin_bypass_possible === false;
+      let residual;
+      if (!inescapable_merge) {
+        if (enforcement_state === "ENFORCING")
+          residual = "admin_bypass_open";
+        else if (enforcement_state === "ADVISORY")
+          residual = "protection_advisory_only";
+        else
+          residual = "protection_not_configured";
+      }
+      return {
+        merge_allowed: true,
+        state: "success",
+        reason: "allow_current_head",
+        enforcement_state,
+        inescapable_merge,
+        ...residual ? { residual } : {},
+        detail
+      };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/deploy-gate.js
+var require_deploy_gate = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/deploy-gate.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.deployGate = deployGate;
+    function norm(s) {
+      return String(s == null ? "" : s).trim().toLowerCase();
+    }
+    function sameNorm(a, b, allowPrefix) {
+      const na = norm(a);
+      const nb = norm(b);
+      if (!na || !nb)
+        return false;
+      if (na === nb)
+        return true;
+      if (allowPrefix && na.length >= 7 && nb.length >= 7 && (na.startsWith(nb) || nb.startsWith(na)))
+        return true;
+      return false;
+    }
+    function isAllowClass(receipt, allowWarnDeploy) {
+      const dec = receipt.decision;
+      const decisionOk = dec === "ALLOW" || dec === "WARN" && allowWarnDeploy === true;
+      if (!decisionOk)
+        return false;
+      const ea = receipt.execution_action;
+      if (ea === void 0 || ea === null || ea === "")
+        return true;
+      return ea === "CONTINUE" || ea === "CONTINUE_WITH_MONITORING";
+    }
+    function idMatchesName(targetId, name) {
+      const t = norm(targetId);
+      const r = norm(name);
+      return t === r || t === `svc:${r}` || t === `repo:${r}` || t.endsWith(`:${r}`) || t.endsWith(`/${r}`);
+    }
+    function deployGate(input) {
+      const target = input.deployTarget || {};
+      const rc = input.requiredContext || {};
+      const enf = rc.enforcement || { enforcement: "UNKNOWN", bypass_possible: true };
+      const enforcement_state = enf.enforcement;
+      const opRequired = rc.operation ?? "deploy";
+      const requireEnv = rc.require_bound_environment !== false;
+      const requireArt = rc.require_bound_artifact !== false;
+      const allowPending = input.allowPending ?? rc.allowPending ?? false;
+      const allowWarnDeploy = input.allowWarnDeploy ?? rc.allowWarnDeploy ?? false;
+      const allowPrefix = input.allowPrefixCompare ?? rc.allowPrefixCompare ?? false;
+      const receipt = input.receipt;
+      const detail = {
+        environment: norm(target.environment),
+        artifact_id: norm(target.artifact_id),
+        bound_environment: receipt && receipt.bound_environment != null ? norm(receipt.bound_environment) : null,
+        bound_artifact_id: receipt && receipt.bound_artifact_id != null ? norm(receipt.bound_artifact_id) : null,
+        operation: receipt && receipt.operation != null ? String(receipt.operation) : null
+      };
+      const deny = (state, reason) => ({
+        deploy_allowed: false,
+        state,
+        reason,
+        enforcement_state,
+        inescapable_deploy: false,
+        detail
+      });
+      if (!target.environment || String(target.environment).trim() === "" || !target.artifact_id || String(target.artifact_id).trim() === "") {
+        return deny(allowPending ? "pending" : "failure", "inputs_incomplete");
+      }
+      if (receipt === null || receipt === void 0) {
+        return deny(allowPending ? "pending" : "failure", "no_receipt");
+      }
+      if (receipt.currently_authorized !== true) {
+        return deny("failure", "receipt_not_authorized");
+      }
+      if (receipt.operation == null || norm(receipt.operation) !== norm(opRequired)) {
+        return deny("failure", "operation_mismatch");
+      }
+      if (requireEnv) {
+        if (!receipt.bound_environment || !sameNorm(receipt.bound_environment, target.environment, allowPrefix)) {
+          return deny("failure", "env_mismatch");
+        }
+      } else if (receipt.bound_environment && !sameNorm(receipt.bound_environment, target.environment, allowPrefix)) {
+        return deny("failure", "env_mismatch");
+      }
+      if (requireArt) {
+        if (!receipt.bound_artifact_id || !sameNorm(receipt.bound_artifact_id, target.artifact_id, allowPrefix)) {
+          return deny("failure", "stale_artifact");
+        }
+      } else if (receipt.bound_artifact_id && !sameNorm(receipt.bound_artifact_id, target.artifact_id, allowPrefix)) {
+        return deny("failure", "stale_artifact");
+      }
+      if (rc.expected_fingerprint != null && receipt.verdict_fingerprint !== rc.expected_fingerprint) {
+        return deny("failure", "fingerprint_mismatch");
+      }
+      if (rc.expected_body_hash != null && receipt.body_hash !== rc.expected_body_hash) {
+        return deny("failure", "body_hash_mismatch");
+      }
+      if (rc.service && receipt.target_id) {
+        if (!idMatchesName(receipt.target_id, rc.service))
+          return deny("failure", "target_mismatch");
+      } else if (rc.repository && receipt.target_id) {
+        if (!idMatchesName(receipt.target_id, rc.repository))
+          return deny("failure", "target_mismatch");
+      }
+      if (!isAllowClass(receipt, allowWarnDeploy)) {
+        return deny("failure", "decision_not_allow");
+      }
+      const inescapable_deploy = enforcement_state === "ENFORCING" && enf.bypass_possible === false;
+      let residual;
+      if (!inescapable_deploy) {
+        if (enforcement_state === "ENFORCING")
+          residual = "bypass_open";
+        else
+          residual = "enforcement_not_configured";
+      }
+      return {
+        deploy_allowed: true,
+        state: "success",
+        reason: "allow_current_deploy",
+        enforcement_state,
+        inescapable_deploy,
+        ...residual ? { residual } : {},
+        detail
+      };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/coverage-report.js
+var require_coverage_report = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/coverage-report.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.coverageReport = coverageReport;
+    var TEMPLATES = {
+      claim_fully_enforced: "All applicable CodeRifts placements are enforcing and non-bypassable for this target. Residuals outside tetrad (e.g. infra break-glass) may still exist.",
+      claim_partially_enforced: "Partial enforcement: some applicable placements enforce; open gaps: {residuals}.",
+      claim_advisory_only: "CodeRifts is present but no applicable placement is fully enforcing. Gaps: {residuals}.",
+      claim_content_blocked: "Contract artifact content is not fully resolved; enforcement of preflight content is incomplete. Gaps: {residuals}.",
+      claim_unknown: "One or more applicable placements cannot be observed. Cannot attest full enforcement. Gaps: {residuals}.",
+      claim_not_applicable: "No CodeRifts placements are in scope for this target."
+    };
+    var OVERALL_TO_KEY = {
+      FULLY_ENFORCED: "claim_fully_enforced",
+      PARTIALLY_ENFORCED: "claim_partially_enforced",
+      ADVISORY_ONLY: "claim_advisory_only",
+      CONTENT_BLOCKED: "claim_content_blocked",
+      UNKNOWN: "claim_unknown",
+      NOT_APPLICABLE: "claim_not_applicable"
+    };
+    function computeRuntime(applicable, input) {
+      if (!applicable)
+        return { strength: "EXCLUDED", residuals: [], summary: { enforcement_or_coverage: input?.coverage ?? "N/A", inescapable_flag: input?.inescapable_runtime ?? null } };
+      if (input == null)
+        return { strength: "UNKNOWN", residuals: ["runtime_state_missing"], summary: { enforcement_or_coverage: "MISSING", inescapable_flag: null } };
+      const residuals = [...input.residuals ?? []];
+      let strength;
+      if (input.coverage === "COMPLETE" && input.inescapable_runtime === true)
+        strength = "ENFORCING";
+      else if (input.coverage === "UNKNOWN")
+        strength = "UNKNOWN";
+      else
+        strength = "WEAK";
+      if (input.coverage === "BYPASSED")
+        residuals.push("runtime_bypassed");
+      return { strength, residuals, summary: { enforcement_or_coverage: input.coverage, inescapable_flag: input.inescapable_runtime } };
+    }
+    function computeMerge(applicable, input) {
+      if (!applicable)
+        return { strength: "EXCLUDED", residuals: [], summary: { enforcement_or_coverage: input?.enforcement_state ?? "N/A", inescapable_flag: input?.inescapable_merge ?? null } };
+      if (input == null)
+        return { strength: "UNKNOWN", residuals: ["merge_state_missing"], summary: { enforcement_or_coverage: "MISSING", inescapable_flag: null } };
+      const residuals = [...input.residuals ?? []];
+      let strength;
+      if (input.inescapable_merge === true && input.enforcement_state === "ENFORCING")
+        strength = "ENFORCING";
+      else if (input.inescapable_merge === true) {
+        strength = "WEAK";
+        residuals.push("inescapable_flag_inconsistent");
+      } else if (input.enforcement_state === "UNKNOWN")
+        strength = "UNKNOWN";
+      else
+        strength = "WEAK";
+      if (strength === "WEAK") {
+        if (input.enforcement_state === "ENFORCING" && input.inescapable_merge === false)
+          residuals.push("admin_bypass_open");
+        else if (input.enforcement_state === "ABSENT")
+          residuals.push("merge_gate_not_configured");
+        else if (input.enforcement_state === "ADVISORY")
+          residuals.push("merge_gate_advisory");
+      }
+      return { strength, residuals, summary: { enforcement_or_coverage: input.enforcement_state, inescapable_flag: input.inescapable_merge } };
+    }
+    function computeDeploy(applicable, input) {
+      if (!applicable)
+        return { strength: "EXCLUDED", residuals: [], summary: { enforcement_or_coverage: input?.enforcement_state ?? "N/A", inescapable_flag: input?.inescapable_deploy ?? null } };
+      if (input == null)
+        return { strength: "UNKNOWN", residuals: ["deploy_state_missing"], summary: { enforcement_or_coverage: "MISSING", inescapable_flag: null } };
+      const residuals = [...input.residuals ?? []];
+      let strength;
+      if (input.inescapable_deploy === true && input.enforcement_state === "ENFORCING")
+        strength = "ENFORCING";
+      else if (input.inescapable_deploy === true) {
+        strength = "WEAK";
+        residuals.push("inescapable_flag_inconsistent");
+      } else if (input.enforcement_state === "UNKNOWN")
+        strength = "UNKNOWN";
+      else
+        strength = "WEAK";
+      if (strength === "WEAK") {
+        if (input.enforcement_state === "ENFORCING" && input.inescapable_deploy === false)
+          residuals.push("bypass_open");
+        else if (input.enforcement_state === "ABSENT")
+          residuals.push("deploy_path_ungated");
+        else if (input.enforcement_state === "ADVISORY")
+          residuals.push("deploy_gate_advisory");
+      }
+      return { strength, residuals, summary: { enforcement_or_coverage: input.enforcement_state, inescapable_flag: input.inescapable_deploy } };
+    }
+    function computeContent(applicable, input) {
+      if (!applicable)
+        return { strength: "EXCLUDED", residuals: [], summary: { enforcement_or_coverage: input?.coverage ?? "N/A", inescapable_flag: input?.artifacts_ready ?? null } };
+      if (input == null)
+        return { strength: "UNKNOWN", residuals: ["content_state_missing"], summary: { enforcement_or_coverage: "MISSING", inescapable_flag: null } };
+      const residuals = [...input.residuals ?? []];
+      let strength;
+      if (input.coverage === "COMPLETE" || input.coverage === "EMPTY")
+        strength = "ENFORCING";
+      else if (input.coverage === "UNRESOLVED") {
+        strength = "WEAK";
+        residuals.push("content_unresolved");
+      } else if (input.coverage === "PARTIAL") {
+        strength = "WEAK";
+        residuals.push("content_partial");
+      } else
+        strength = "UNKNOWN";
+      return { strength, residuals, summary: { enforcement_or_coverage: input.coverage, inescapable_flag: input.artifacts_ready ?? null } };
+    }
+    function coverageReport(input) {
+      const applicability = input.applicability || { runtime: false, merge: false, deploy: false, content: false };
+      const computed = {
+        runtime: computeRuntime(applicability.runtime === true, input.runtime),
+        merge: computeMerge(applicability.merge === true, input.merge),
+        deploy: computeDeploy(applicability.deploy === true, input.deploy),
+        content: computeContent(applicability.content === true, input.content)
+      };
+      const order = ["runtime", "merge", "deploy", "content"];
+      const isApplicable = (p) => applicability[p] === true;
+      const applicableStrengths = order.filter(isApplicable).map((p) => computed[p].strength);
+      const contentApplicable = isApplicable("content");
+      const contentUnresolved = contentApplicable && input.content != null && input.content.coverage === "UNRESOLVED";
+      const weakPlacements = order.filter((p) => isApplicable(p) && computed[p].strength === "WEAK");
+      let overall;
+      if (applicableStrengths.length === 0) {
+        overall = "NOT_APPLICABLE";
+      } else if (applicableStrengths.every((s) => s === "ENFORCING")) {
+        overall = "FULLY_ENFORCED";
+      } else if (applicableStrengths.some((s) => s === "WEAK") && applicableStrengths.some((s) => s === "ENFORCING")) {
+        overall = contentUnresolved ? "CONTENT_BLOCKED" : "PARTIALLY_ENFORCED";
+      } else if (applicableStrengths.some((s) => s === "WEAK")) {
+        overall = contentUnresolved && weakPlacements.every((p) => p === "content") ? "CONTENT_BLOCKED" : "ADVISORY_ONLY";
+      } else {
+        overall = "UNKNOWN";
+      }
+      const residualSet = /* @__PURE__ */ new Set();
+      for (const p of order)
+        if (isApplicable(p))
+          for (const r of computed[p].residuals)
+            residualSet.add(r);
+      const residuals = [...residualSet].sort();
+      const honest_claim_key = OVERALL_TO_KEY[overall];
+      const honest_claim_language = TEMPLATES[honest_claim_key].replace("{residuals}", residuals.length ? residuals.join(", ") : "none");
+      const flags = {
+        may_claim_inescapable_runtime: isApplicable("runtime") && computed.runtime.strength === "ENFORCING",
+        may_claim_inescapable_merge: isApplicable("merge") && computed.merge.strength === "ENFORCING",
+        may_claim_inescapable_deploy: isApplicable("deploy") && computed.deploy.strength === "ENFORCING",
+        may_claim_full_tetrad: overall === "FULLY_ENFORCED"
+      };
+      const per_placement = order.map((p) => ({
+        placement: p,
+        applicable: isApplicable(p),
+        strength: computed[p].strength,
+        summary: computed[p].summary,
+        residuals: isApplicable(p) ? [...new Set(computed[p].residuals)].sort() : []
+      }));
+      return { overall_coverage: overall, per_placement, residuals, honest_claim_key, honest_claim_language, flags };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/index.js
+var require_cjs4 = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.coverageReport = exports2.deployGate = exports2.gateDecision = exports2.RegistryConstructionError = exports2.guardToolRegistry = exports2.globToRegExp = exports2.matchGlob = exports2.resolveArtifacts = exports2.deriveKeySignal = exports2.pathClass = exports2.classifyCommand = exports2.projectState = exports2.emptySessionState = exports2.computeTainted = exports2.evaluate = exports2.updateSession = exports2.SESSION_TAINT_VERSION = exports2.SessionTaintTracker = exports2.readDecision = exports2.computeBundleFingerprint = exports2.computeArtifactDigest = exports2.evaluateEnvelope = exports2.canonicalJson = exports2.computeBodyHash = exports2.bindReceiptToEnvelope = exports2.DETECTOR_VERSION = exports2.builtinDetector = exports2.guardToolCall = void 0;
+    var guard_js_1 = require_guard();
+    Object.defineProperty(exports2, "guardToolCall", { enumerable: true, get: function() {
+      return guard_js_1.guardToolCall;
+    } });
+    var detector_js_1 = require_detector();
+    Object.defineProperty(exports2, "builtinDetector", { enumerable: true, get: function() {
+      return detector_js_1.builtinDetector;
+    } });
+    Object.defineProperty(exports2, "DETECTOR_VERSION", { enumerable: true, get: function() {
+      return detector_js_1.DETECTOR_VERSION;
+    } });
+    var receipt_binding_js_1 = require_receipt_binding();
+    Object.defineProperty(exports2, "bindReceiptToEnvelope", { enumerable: true, get: function() {
+      return receipt_binding_js_1.bindReceiptToEnvelope;
+    } });
+    Object.defineProperty(exports2, "computeBodyHash", { enumerable: true, get: function() {
+      return receipt_binding_js_1.computeBodyHash;
+    } });
+    Object.defineProperty(exports2, "canonicalJson", { enumerable: true, get: function() {
+      return receipt_binding_js_1.canonicalJson;
+    } });
+    var enforcement_gate_js_1 = require_enforcement_gate();
+    Object.defineProperty(exports2, "evaluateEnvelope", { enumerable: true, get: function() {
+      return enforcement_gate_js_1.evaluateEnvelope;
+    } });
+    Object.defineProperty(exports2, "computeArtifactDigest", { enumerable: true, get: function() {
+      return enforcement_gate_js_1.computeArtifactDigest;
+    } });
+    Object.defineProperty(exports2, "computeBundleFingerprint", { enumerable: true, get: function() {
+      return enforcement_gate_js_1.computeBundleFingerprint;
+    } });
+    var sdk_1 = require_cjs3();
+    Object.defineProperty(exports2, "readDecision", { enumerable: true, get: function() {
+      return sdk_1.readDecision;
+    } });
+    var session_taint_js_1 = require_session_taint();
+    Object.defineProperty(exports2, "SessionTaintTracker", { enumerable: true, get: function() {
+      return session_taint_js_1.SessionTaintTracker;
+    } });
+    Object.defineProperty(exports2, "SESSION_TAINT_VERSION", { enumerable: true, get: function() {
+      return session_taint_js_1.SESSION_TAINT_VERSION;
+    } });
+    Object.defineProperty(exports2, "updateSession", { enumerable: true, get: function() {
+      return session_taint_js_1.updateSession;
+    } });
+    Object.defineProperty(exports2, "evaluate", { enumerable: true, get: function() {
+      return session_taint_js_1.evaluate;
+    } });
+    Object.defineProperty(exports2, "computeTainted", { enumerable: true, get: function() {
+      return session_taint_js_1.computeTainted;
+    } });
+    Object.defineProperty(exports2, "emptySessionState", { enumerable: true, get: function() {
+      return session_taint_js_1.emptySessionState;
+    } });
+    Object.defineProperty(exports2, "projectState", { enumerable: true, get: function() {
+      return session_taint_js_1.projectState;
+    } });
+    Object.defineProperty(exports2, "classifyCommand", { enumerable: true, get: function() {
+      return session_taint_js_1.classifyCommand;
+    } });
+    Object.defineProperty(exports2, "pathClass", { enumerable: true, get: function() {
+      return session_taint_js_1.pathClass;
+    } });
+    Object.defineProperty(exports2, "deriveKeySignal", { enumerable: true, get: function() {
+      return session_taint_js_1.deriveKeySignal;
+    } });
+    var artifact_resolver_js_1 = require_artifact_resolver();
+    Object.defineProperty(exports2, "resolveArtifacts", { enumerable: true, get: function() {
+      return artifact_resolver_js_1.resolve;
+    } });
+    var resolver_glob_js_1 = require_resolver_glob();
+    Object.defineProperty(exports2, "matchGlob", { enumerable: true, get: function() {
+      return resolver_glob_js_1.matchGlob;
+    } });
+    Object.defineProperty(exports2, "globToRegExp", { enumerable: true, get: function() {
+      return resolver_glob_js_1.globToRegExp;
+    } });
+    var tool_registry_js_1 = require_tool_registry();
+    Object.defineProperty(exports2, "guardToolRegistry", { enumerable: true, get: function() {
+      return tool_registry_js_1.guardToolRegistry;
+    } });
+    Object.defineProperty(exports2, "RegistryConstructionError", { enumerable: true, get: function() {
+      return tool_registry_js_1.RegistryConstructionError;
+    } });
+    var merge_gate_js_1 = require_merge_gate();
+    Object.defineProperty(exports2, "gateDecision", { enumerable: true, get: function() {
+      return merge_gate_js_1.gateDecision;
+    } });
+    var deploy_gate_js_1 = require_deploy_gate();
+    Object.defineProperty(exports2, "deployGate", { enumerable: true, get: function() {
+      return deploy_gate_js_1.deployGate;
+    } });
+    var coverage_report_js_1 = require_coverage_report();
+    Object.defineProperty(exports2, "coverageReport", { enumerable: true, get: function() {
+      return coverage_report_js_1.coverageReport;
+    } });
+  }
+});
+
+// src/commands/deploy-gate.js
+var require_deploy_gate2 = __commonJS({
+  "src/commands/deploy-gate.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var chalk = require_source();
+    var { deployGate } = require_cjs4();
+    var { renderJson } = require_json2();
+    if (process.env.NO_COLOR) chalk.level = 0;
+    var REPAIRABLE = /* @__PURE__ */ new Set(["env_mismatch", "stale_artifact", "operation_mismatch", "receipt_not_authorized", "fingerprint_mismatch", "body_hash_mismatch"]);
+    function enforceSignal(options) {
+      return options && options.enforce === true || String(process.env.CODERIFTS_DEPLOY_ENFORCE || "").toLowerCase() === "true";
+    }
+    function observeCDEnforcement(options = {}) {
+      const envVal = String(process.env.CODERIFTS_DEPLOY_ENFORCE || "").toLowerCase();
+      let enforcement;
+      if (enforceSignal(options)) enforcement = "ENFORCING";
+      else if (envVal === "unknown") enforcement = "UNKNOWN";
+      else enforcement = "ADVISORY";
+      const bypass_possible = String(process.env.CODERIFTS_DEPLOY_NO_BYPASS || "").toLowerCase() !== "true";
+      return {
+        enforcement,
+        bypass_possible,
+        step_is_required: enforcement === "ENFORCING",
+        required_step_name: "CodeRifts / deploy-gate",
+        attestation_source: "cli_flag"
+      };
+    }
+    function deployReportResiduals(state, inescapable, enforcement) {
+      const out = [];
+      if (state === "success" && inescapable !== true) {
+        if (enforcement === "ENFORCING") out.push("bypass_open");
+        else if (enforcement === "ADVISORY") out.push("deploy_gate_advisory");
+        else if (enforcement === "ABSENT") out.push("deploy_path_ungated");
+      }
+      return out;
+    }
+    function deployCoverageInput(enforcement_state, inescapable_deploy) {
+      return { enforcement_state, inescapable_deploy: inescapable_deploy === true, applicability_attested: true };
+    }
+    function deployBind({ environment, artifact_id, receipt, observed_cd_enforcement, expected_fingerprint, expected_body_hash }) {
+      const attested_enforcement = observed_cd_enforcement && observed_cd_enforcement.enforcement || "UNKNOWN";
+      if (!receipt) {
+        return {
+          deploy_check_status: "pending",
+          reason: "no_receipt",
+          must_re_preflight: true,
+          attested_enforcement,
+          gate: null,
+          report_residuals: [],
+          coverage_deploy_input: deployCoverageInput(attested_enforcement, false)
+        };
+      }
+      const requiredContext = {
+        operation: "deploy",
+        enforcement: {
+          enforcement: attested_enforcement,
+          // fail-closed: bypass is possible unless observation proved it disabled.
+          bypass_possible: !(observed_cd_enforcement && observed_cd_enforcement.bypass_possible === false)
+        }
+      };
+      if (attested_enforcement === "ENFORCING") {
+        if (expected_fingerprint != null) requiredContext.expected_fingerprint = expected_fingerprint;
+        if (expected_body_hash != null) requiredContext.expected_body_hash = expected_body_hash;
+      }
+      const gate = deployGate({ deployTarget: { environment, artifact_id }, receipt, requiredContext });
+      const inescapable_deploy = gate.inescapable_deploy === true;
+      return {
+        deploy_check_status: gate.state,
+        reason: gate.reason,
+        must_re_preflight: REPAIRABLE.has(gate.reason),
+        attested_enforcement,
+        gate: { deploy_allowed: gate.deploy_allowed, reason: gate.reason, inescapable_deploy },
+        report_residuals: deployReportResiduals(gate.state, inescapable_deploy, attested_enforcement),
+        coverage_deploy_input: deployCoverageInput(attested_enforcement, inescapable_deploy)
+      };
+    }
+    function clampExit(deployCheckStatus, enforce) {
+      if (deployCheckStatus === "success") return 0;
+      if (deployCheckStatus === "failure" && enforce === true) return 1;
+      return 0;
+    }
+    function readReceiptFile(filePath) {
+      if (!filePath) return null;
+      const resolved = path.resolve(filePath);
+      if (!fs.existsSync(resolved)) return null;
+      try {
+        return JSON.parse(fs.readFileSync(resolved, "utf-8"));
+      } catch (_) {
+        return null;
+      }
+    }
+    function renderDeployGateTerminal(bind, enforce) {
+      const g = bind.gate;
+      const color = bind.deploy_check_status === "success" ? chalk.green : bind.deploy_check_status === "failure" ? chalk.red : chalk.yellow;
+      const lines = [];
+      lines.push("");
+      lines.push(chalk.bold(`  CodeRifts deploy-gate \u2014 ${color(bind.deploy_check_status.toUpperCase())}`));
+      lines.push(`  Reason:             ${bind.reason}`);
+      lines.push(`  Enforcement:        ${bind.attested_enforcement}`);
+      lines.push(`  inescapable_deploy: ${g ? g.inescapable_deploy : false}`);
+      if (bind.report_residuals.length) lines.push(`  Residuals:          ${bind.report_residuals.join(", ")}`);
+      if (bind.must_re_preflight) lines.push(chalk.yellow("  Action: re-preflight this { environment, artifact } \u2014 the receipt does not authorize it."));
+      lines.push("");
+      lines.push(enforce ? chalk.dim("  Enforcing \u2014 a failing gate exits non-zero (blocks the deploy step).") : chalk.dim("  Advisory (phase 1) \u2014 does not block the deploy (exit 0)."));
+      lines.push("");
+      return lines.join("\n");
+    }
+    async function runDeployGate(options = {}) {
+      const environment = options.env;
+      const artifactId = options.artifact;
+      if (!environment || !artifactId) {
+        console.error(chalk.red("Error: --env and --artifact are required."));
+        process.exit(1);
+        return;
+      }
+      const enforce = enforceSignal(options);
+      const receipt = readReceiptFile(options.receipt);
+      const observed = observeCDEnforcement({ enforce });
+      const bind = deployBind({ environment, artifact_id: artifactId, receipt, observed_cd_enforcement: observed });
+      const code = clampExit(bind.deploy_check_status, enforce);
+      if (options.json) {
+        console.log(renderJson({ command: "deploy-gate", environment, artifact_id: artifactId, phase: enforce ? "enforcing" : "advisory", exit_code: code, ...bind }));
+      } else {
+        console.log(renderDeployGateTerminal(bind, enforce));
+      }
+      process.exit(code);
+    }
+    module2.exports = {
+      runDeployGate,
+      deployBind,
+      observeCDEnforcement,
+      clampExit,
+      readReceiptFile,
+      renderDeployGateTerminal
+    };
+  }
+});
+
 // src/commands/init.js
 var require_init = __commonJS({
   "src/commands/init.js"(exports2, module2) {
@@ -75782,7 +79330,7 @@ var require_zipWith = __commonJS({
 });
 
 // node_modules/rxjs/dist/cjs/index.js
-var require_cjs3 = __commonJS({
+var require_cjs5 = __commonJS({
   "node_modules/rxjs/dist/cjs/index.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
@@ -77099,7 +80647,7 @@ var require_run_async = __commonJS({
 var require_utils3 = __commonJS({
   "node_modules/inquirer/lib/utils/utils.js"(exports2) {
     "use strict";
-    var { from, of } = require_cjs3();
+    var { from, of } = require_cjs5();
     var runAsync = require_run_async();
     exports2.fetchAsyncQuestionProperty = function(question, prop, answers) {
       if (typeof question[prop] !== "function") {
@@ -77124,7 +80672,7 @@ var require_prompt = __commonJS({
       get: require_get2(),
       set: require_set3()
     };
-    var { defer, empty, from, of } = require_cjs3();
+    var { defer, empty, from, of } = require_cjs5();
     var { concatMap, filter, publish, reduce } = require_operators();
     var runAsync = require_run_async();
     var utils = require_utils3();
@@ -79838,7 +83386,7 @@ var require_base = __commonJS({
 var require_events = __commonJS({
   "node_modules/inquirer/lib/utils/events.js"(exports2, module2) {
     "use strict";
-    var { fromEvent } = require_cjs3();
+    var { fromEvent } = require_cjs5();
     var { filter, map, share, takeUntil } = require_operators();
     function normalizeKeypressEvents(value, key) {
       return { value, key: key || {} };
@@ -90636,7 +94184,7 @@ var require_editor = __commonJS({
     var { editAsync } = require_commonjs();
     var Base = require_base();
     var observe = require_events();
-    var { Subject } = require_cjs3();
+    var { Subject } = require_cjs5();
     var EditorPrompt = class extends Base {
       /**
        * Start the Inquiry session
@@ -91018,7 +94566,9 @@ var require_vectors_mcp_fpfn = __commonJS({
         expected: {
           has_breaking: false,
           should_flag_poison: false,
-          risk_max: 20,
+          risk_max: 0,
+          bounds_changelog: "risk_max 20 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "safe vector scores 0 on the pinned path - max 0 catches any inflation (detection-only)",
           deep_signals: [],
           notes: "Purely additive optional property. Agents that do not send 'limit' continue to work. Must NOT trigger breaking or high risk."
         }
@@ -91052,7 +94602,9 @@ var require_vectors_mcp_fpfn = __commonJS({
         expected: {
           has_breaking: false,
           should_flag_poison: false,
-          risk_max: 15,
+          risk_max: 0,
+          bounds_changelog: "risk_max 15 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "safe vector scores 0 on the pinned path - max 0 catches any inflation (detection-only)",
           deep_signals: [],
           notes: "Input enum expansion is non-breaking for callers. Existing 'read'/'write' payloads still validate. Do not cry wolf."
         }
@@ -91085,7 +94637,9 @@ var require_vectors_mcp_fpfn = __commonJS({
         expected: {
           has_breaking: false,
           should_flag_poison: false,
-          risk_max: 25,
+          risk_max: 0,
+          bounds_changelog: "risk_max 25 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "safe vector scores 0 on the pinned path - max 0 catches any inflation (detection-only)",
           deep_signals: ["composition_branch_count_changed"],
           notes: "New branch is additive. Old 'text' payloads continue to match first branch exactly. Non-breaking per rules."
         }
@@ -91109,7 +94663,9 @@ var require_vectors_mcp_fpfn = __commonJS({
         expected: {
           has_breaking: false,
           should_flag_poison: false,
-          risk_max: 5,
+          risk_max: 0,
+          bounds_changelog: "risk_max 5 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "safe vector scores 0 on the pinned path - max 0 catches any inflation (detection-only)",
           deep_signals: ["description_changed"],
           notes: "Description change only. No structural impact and no suspicious content. Must stay low risk / non-breaking."
         }
@@ -91141,7 +94697,8 @@ var require_vectors_mcp_fpfn = __commonJS({
         expected: {
           has_breaking: false,
           should_flag_poison: false,
-          risk_max: 10,
+          risk_max: 24,
+          bounds_changelog: "risk_max 10 -> 24 (recalibrated 2026-07 to measured 20 on the oasdiff-1.11.11 pinned path)",
           deep_signals: [],
           notes: "Adding fields to output is generally non-breaking for agents (they can ignore unknown keys unless strict validation)."
         }
@@ -91168,7 +94725,9 @@ var require_vectors_mcp_fpfn = __commonJS({
         expected: {
           has_breaking: false,
           should_flag_poison: false,
-          risk_max: 5,
+          risk_max: 0,
+          bounds_changelog: "risk_max 5 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "safe vector scores 0 on the pinned path - max 0 catches any inflation (detection-only)",
           deep_signals: [],
           notes: "Vendor extensions and unknown keywords do not affect validation contract for existing payloads."
         }
@@ -91202,7 +94761,8 @@ var require_vectors_mcp_fpfn = __commonJS({
         expected: {
           has_breaking: true,
           should_flag_poison: false,
-          risk_min: 60,
+          risk_min: 24,
+          bounds_changelog: "risk_min 60 -> 24 (recalibrated 2026-07 to measured 30 on the oasdiff-1.11.11 pinned path)",
           deep_signals: ["required_added", "property_removed"],
           notes: "Old agents send 'title'. New contract requires 'name'. Direct break. Must be detected as breaking despite surface 'add+remove' appearance."
         }
@@ -91233,7 +94793,8 @@ var require_vectors_mcp_fpfn = __commonJS({
         },
         expected: {
           has_breaking: true,
-          risk_min: 45,
+          risk_min: 16,
+          bounds_changelog: "risk_min 45 -> 16 (recalibrated 2026-07 to measured 20 on the oasdiff-1.11.11 pinned path)",
           deep_signals: ["enum_value_removed"],
           notes: "Server will no longer emit 'error' state. Any agent logic or monitoring keyed on it breaks. Must flag."
         }
@@ -91271,7 +94832,9 @@ var require_vectors_mcp_fpfn = __commonJS({
         },
         expected: {
           has_breaking: true,
-          risk_min: 70,
+          risk_min: 0,
+          bounds_changelog: "risk_min 70 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "risk scorer produces no signal for this vector class - detection-only guard",
           deep_signals: ["conditional_required_added", "required_added"],
           notes: "When mode=full, 'reason' becomes mandatory. Agents using the old manifest for full updates will fail validation. Must catch deep conditional."
         }
@@ -91314,7 +94877,9 @@ var require_vectors_mcp_fpfn = __commonJS({
         expected: {
           has_breaking: true,
           should_flag_poison: true,
-          risk_min: 80,
+          risk_min: 0,
+          bounds_changelog: "risk_min 80 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "risk scorer produces no signal for this vector class - detection-only guard",
           deep_signals: ["$defs_changed", "required_added"],
           poison_signals: ["Ignore previous", "always include"],
           notes: "Ref target now requires extra field + contains FSP instruction. Classic deep + poison vector. Must surface both structural break and poisoning."
@@ -91350,7 +94915,9 @@ var require_vectors_mcp_fpfn = __commonJS({
         expected: {
           has_breaking: false,
           should_flag_poison: true,
-          risk_min: 55,
+          risk_min: 0,
+          bounds_changelog: "risk_min 55 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "risk scorer produces no signal for this vector class - detection-only guard",
           poison_signals: ["send a copy", "attacker.example"],
           notes: "Structural contract same, but FSP in a property description. Shallow tools miss it. Full-schema detector + risk must catch."
         }
@@ -91383,7 +94950,9 @@ var require_vectors_mcp_fpfn = __commonJS({
         },
         expected: {
           has_breaking: true,
-          risk_min: 65,
+          risk_min: 0,
+          bounds_changelog: "risk_min 65 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "risk scorer produces no signal for this vector class - detection-only guard",
           deep_signals: ["required_added"],
           notes: "The second allOf fragment now requires 'data'. After merge the whole schema requires it. Must detect via normalization + allOf handling."
         }
@@ -91414,7 +94983,8 @@ var require_vectors_mcp_fpfn = __commonJS({
         },
         expected: {
           has_breaking: true,
-          risk_min: 70,
+          risk_min: 16,
+          bounds_changelog: "risk_min 70 -> 16 (recalibrated 2026-07 to measured 20 on the oasdiff-1.11.11 pinned path)",
           deep_signals: ["conditional_required_added"],
           notes: "Error path now mandates 'result'. Agents and any gateway transformation that relied on optional result on error will break or behave differently."
         }
@@ -91467,7 +95037,9 @@ var require_vectors_openapi_fpfn = __commonJS({
         },
         expected: {
           has_breaking: false,
-          risk_max: 10,
+          risk_max: 0,
+          bounds_changelog: "risk_max 10 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "safe vector scores 0 on the pinned path - max 0 catches any inflation (detection-only)",
           notes: "Optional query param addition never breaks existing calls that omit it. Must not flag."
         }
       },
@@ -91520,7 +95092,9 @@ var require_vectors_openapi_fpfn = __commonJS({
         },
         expected: {
           has_breaking: false,
-          risk_max: 8,
+          risk_max: 0,
+          bounds_changelog: "risk_max 8 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "safe vector scores 0 on the pinned path - max 0 catches any inflation (detection-only)",
           notes: "Extra response fields are ignored by most clients unless they use strict additionalProperties:false. Non-breaking."
         }
       },
@@ -91577,7 +95151,9 @@ var require_vectors_openapi_fpfn = __commonJS({
         },
         expected: {
           has_breaking: false,
-          risk_max: 12,
+          risk_max: 0,
+          bounds_changelog: "risk_max 12 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "safe vector scores 0 on the pinned path - max 0 catches any inflation (detection-only)",
           notes: "Response enum expansion gives clients more cases to handle optionally. Existing handling of open/closed remains valid."
         }
       },
@@ -91613,7 +95189,8 @@ var require_vectors_openapi_fpfn = __commonJS({
         },
         expected: {
           has_breaking: true,
-          risk_min: 70,
+          risk_min: 2,
+          bounds_changelog: "risk_min 70 -> 2 (recalibrated 2026-07 to measured 3 on the production-faithful path - no pattern boost)",
           notes: "All prior requests without 'org' now invalid. Direct breaking change for agents and SDK clients. Must be caught."
         }
       },
@@ -91718,7 +95295,8 @@ var require_vectors_openapi_fpfn = __commonJS({
         },
         expected: {
           has_breaking: true,
-          risk_min: 75,
+          risk_min: 4,
+          bounds_changelog: "risk_min 75 -> 4 (recalibrated 2026-07 to measured 6 on the production-faithful path - no pattern boost)",
           notes: "Request payload shape changed for a required identifier. Old 'userId' submissions rejected. Must detect rename as breaking."
         }
       },
@@ -91842,7 +95420,8 @@ var require_vectors_openapi_fpfn = __commonJS({
         },
         expected: {
           has_breaking: true,
-          risk_min: 50,
+          risk_min: 6,
+          bounds_changelog: "risk_min 50 -> 6 (recalibrated 2026-07 to measured 8 on the production-faithful path - no pattern boost)",
           notes: "Request-side tightening rejects previously-valid payloads. Must be caught."
         }
       },
@@ -91896,7 +95475,9 @@ var require_vectors_openapi_fpfn = __commonJS({
         },
         expected: {
           has_breaking: false,
-          risk_max: 10,
+          risk_max: 0,
+          bounds_changelog: "risk_max 10 -> 0 (recalibrated 2026-07 to measured 0 on the oasdiff-1.11.11 pinned path)",
+          risk_note: "safe vector scores 0 on the pinned path - max 0 catches any inflation (detection-only)",
           notes: "Request-side loosening (nullable false->true, format unchanged): all previously-valid payloads stay valid. Must NOT be flagged breaking."
         }
       }
@@ -91997,7 +95578,7 @@ var require_mcp_schema_normalizer = __commonJS({
       return parts.join("|");
     }
     function normalizeConditionals(schema, warnings = []) {
-      let result = { ...schema };
+      const result = { ...schema };
       if (result.if) result.if = normalizeMcpSchema(result.if, { warnings }).canonical;
       if (result.then) result.then = normalizeMcpSchema(result.then, { warnings }).canonical;
       if (result.else) result.else = normalizeMcpSchema(result.else, { warnings }).canonical;
@@ -92821,6 +96402,10 @@ program.command("diff <old-spec> <new-spec>").description("Compare two OpenAPI s
   const { diff } = require_diff();
   await diff(oldSpec, newSpec, options);
 });
+program.command("deploy-gate").description("Gate a deploy on the current { environment, artifact } using a preflight receipt (phase-1 advisory)").option("--env <environment>", "Target environment (e.g. production, staging)").option("--artifact <artifact_id>", "Immutable artifact identity being deployed (content digest or commit SHA)").option("--receipt <file>", "Path to the deploy-scoped receipt JSON produced by preflight").option("--json", "Output the binding result as JSON").option("--enforce", "Treat the step as enforcing: attest ENFORCING and exit non-zero on a gate failure").action(async (options) => {
+  const { runDeployGate } = require_deploy_gate2();
+  await runDeployGate(options);
+});
 program.command("init [template]").description("Generate a .coderifts.yml from a policy template (startup, growth, fintech, public-api, microservices)").action(async (template) => {
   const { init } = require_init();
   await init(template);
@@ -92880,5 +96465,5 @@ mime-types/index.js:
    *)
 
 axios/dist/node/axios.cjs:
-  (*! Axios v1.17.0 Copyright (c) 2026 Matt Zabriskie and contributors *)
+  (*! Axios v1.18.1 Copyright (c) 2026 Matt Zabriskie and contributors *)
 */