coderifts 1.8.4 → 2.0.0

package/dist/cli.js

@@ -3007,7 +3007,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "coderifts",
-      version: "1.8.4",
+      version: "2.0.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,11 +3050,12 @@ 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",
         inquirer: "^8.2.6",
-        "js-yaml": "^4.2.0",
+        "js-yaml": "^4.3.1",
         "openapi-diff": "^0.24.1",
         ora: "^5.4.1"
       },
@@ -3062,7 +3063,9 @@ var require_package = __commonJS({
         "z-schema": "^7.2.0",
         "json-schema-ref-parser": "npm:@apidevtools/json-schema-ref-parser@^11.7.3",
         "form-data": "^4.0.6",
-        axios: ">=1.18.0"
+        axios: ">=1.18.0",
+        "fast-uri": ">=3.1.5",
+        "brace-expansion": "5.0.9"
       },
       devDependencies: {
         esbuild: "^0.28.1"
@@ -4366,7 +4369,7 @@ var require_templates = __commonJS({
         if (!Number.isNaN(number)) {
           results.push(number);
         } else if (matches = chunk.match(STRING_REGEX)) {
-          results.push(matches[2].replace(ESCAPE_REGEX, (m, escape2, character) => escape2 ? unescape2(escape2) : character));
+          results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape2(escape) : character));
         } else {
           throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
         }
@@ -11255,7 +11258,7 @@ var require_omap = __commonJS({
     var _toString = Object.prototype.toString;
     function resolveYamlOmap(data) {
       if (data === null) return true;
-      const objectKeys = [];
+      const objectKeys = {};
       const object = data;
       for (let index = 0, length = object.length; index < length; index += 1) {
         const pair = object[index];
@@ -11269,8 +11272,8 @@ var require_omap = __commonJS({
           }
         }
         if (!pairHasKey) return false;
-        if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
-        else return false;
+        if (_hasOwnProperty.call(objectKeys, pairKey)) return false;
+        Object.defineProperty(objectKeys, pairKey, { value: true });
       }
       return true;
     }
@@ -24777,7 +24780,7 @@ var require_lodash = __commonJS({
           position -= target.length;
           return position >= 0 && string.slice(position, end) == target;
         }
-        function escape2(string) {
+        function escape(string) {
           string = toString(string);
           return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string;
         }
@@ -25388,7 +25391,7 @@ var require_lodash = __commonJS({
         lodash.divide = divide;
         lodash.endsWith = endsWith;
         lodash.eq = eq;
-        lodash.escape = escape2;
+        lodash.escape = escape;
         lodash.escapeRegExp = escapeRegExp;
         lodash.every = every;
         lodash.find = find;
@@ -29362,6 +29365,7 @@ var require_utils2 = __commonJS({
     var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
     var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
     var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
+    var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/?]$/iu);
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -29504,7 +29508,7 @@ var require_utils2 = __commonJS({
               continue;
             }
           } else if (input[0] === "/") {
-            if (input[1] === "." || input[1] === "/") {
+            if (input[1] === ".") {
               output.push("/");
               break;
             }
@@ -29586,10 +29590,30 @@ var require_utils2 = __commonJS({
       }
       return output;
     }
+    var BYTE_HEX = new Array(256);
+    {
+      const HEX_DIGITS = "0123456789ABCDEF";
+      for (let i = 0; i < 256; i++) {
+        BYTE_HEX[i] = "%" + HEX_DIGITS[i >> 4] + HEX_DIGITS[i & 15];
+      }
+    }
+    function isEscapeSafe(cp) {
+      return cp >= 48 && cp <= 57 || cp >= 65 && cp <= 90 || cp >= 97 && cp <= 122 || cp === 42 || cp === 43 || cp === 45 || cp === 46 || cp === 47 || cp === 64 || cp === 95;
+    }
+    function percentEncodeNonAscii(cp) {
+      if (cp < 2048) {
+        return BYTE_HEX[192 | cp >> 6] + BYTE_HEX[128 | cp & 63];
+      }
+      if (cp < 65536) {
+        return BYTE_HEX[224 | cp >> 12] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+      }
+      return BYTE_HEX[240 | cp >> 18] + BYTE_HEX[128 | cp >> 12 & 63] + BYTE_HEX[128 | cp >> 6 & 63] + BYTE_HEX[128 | cp & 63];
+    }
     function normalizePathEncoding(input) {
       let output = "";
       for (let i = 0; i < input.length; i++) {
-        if (input[i] === "%" && i + 2 < input.length) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
           const hex = input.slice(i + 1, i + 3);
           if (isHexPair(hex)) {
             const normalizedHex = hex.toUpperCase();
@@ -29603,10 +29627,66 @@ var require_utils2 = __commonJS({
             continue;
           }
         }
-        if (isPathCharacter(input[i])) {
-          output += input[i];
+        if (isPathCharacter(ch)) {
+          output += ch;
         } else {
-          output += escape(input[i]);
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        }
+      }
+      return output;
+    }
+    function normalizeQueryFragmentEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
+          const hex = input.slice(i + 1, i + 3);
+          if (isHexPair(hex)) {
+            const normalizedHex = hex.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isQueryFragmentCharacter(ch)) {
+          output += ch;
+        } else {
+          const code = input.charCodeAt(i);
+          if (code < 128) {
+            output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+          } else if (code < 55296 || code > 57343) {
+            output += percentEncodeNonAscii(code);
+          } else if (code <= 56319 && i + 1 < input.length) {
+            const low = input.charCodeAt(i + 1);
+            if (low >= 56320 && low <= 57343) {
+              output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+              i++;
+            } else {
+              output += percentEncodeNonAscii(65533);
+            }
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
         }
       }
       return output;
@@ -29614,7 +29694,8 @@ var require_utils2 = __commonJS({
     function escapePreservingEscapes(input) {
       let output = "";
       for (let i = 0; i < input.length; i++) {
-        if (input[i] === "%" && i + 2 < input.length) {
+        const ch = input[i];
+        if (ch === "%" && i + 2 < input.length) {
           const hex = input.slice(i + 1, i + 3);
           if (isHexPair(hex)) {
             output += "%" + hex.toUpperCase();
@@ -29622,7 +29703,22 @@ var require_utils2 = __commonJS({
             continue;
           }
         }
-        output += escape(input[i]);
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += isEscapeSafe(code) ? ch : BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
       }
       return output;
     }
@@ -29656,6 +29752,7 @@ var require_utils2 = __commonJS({
       reescapeHostDelimiters,
       normalizePercentEncoding,
       normalizePathEncoding,
+      normalizeQueryFragmentEncoding,
       escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
@@ -29880,7 +29977,7 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "node_modules/fast-uri/index.js"(exports2, module2) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils2();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, normalizeQueryFragmentEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils2();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     function normalize(uri, options) {
       if (typeof uri === "string") {
@@ -29894,7 +29991,12 @@ var require_fast_uri = __commonJS({
     }
     function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
+      const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
+      const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
+      if (baseMalformed || relativeMalformed) {
+        throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+      }
+      const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
@@ -30020,6 +30122,7 @@ var require_fast_uri = __commonJS({
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
     var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+    var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
     function getParseError(parsed, matches) {
       if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
@@ -30054,9 +30157,23 @@ var require_fast_uri = __commonJS({
         parsed.error = "URI authority must not contain a literal backslash.";
         malformedAuthorityOrPort = true;
       }
+      const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+      if (introducerMatch !== null) {
+        const region = introducerMatch[1];
+        const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+        if (normalizedRegion.length >= 2) {
+          if (normalizedRegion.slice(0, 2) !== "//") {
+            parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+            malformedAuthorityOrPort = true;
+          } else if (region.length !== normalizedRegion.length) {
+            parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+            malformedAuthorityOrPort = true;
+          }
+        }
+      }
       const matches = uri.match(URI_PARSE);
       if (matches) {
-        parsed.scheme = matches[1];
+        parsed.scheme = matches[1] === void 0 ? void 0 : matches[1].toLowerCase();
         parsed.userinfo = matches[3];
         parsed.host = matches[4];
         parsed.port = parseInt(matches[5], 10);
@@ -30115,12 +30232,11 @@ var require_fast_uri = __commonJS({
           if (parsed.path) {
             parsed.path = normalizePathEncoding(parsed.path);
           }
+          if (parsed.query) {
+            parsed.query = normalizeQueryFragmentEncoding(parsed.query);
+          }
           if (parsed.fragment) {
-            try {
-              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
-            } catch {
-              parsed.error = parsed.error || "URI malformed";
-            }
+            parsed.fragment = normalizeQueryFragmentEncoding(parsed.fragment);
           }
         }
         if (schemeHandler && schemeHandler.parse) {
@@ -61749,7 +61865,7 @@ var require_axios = __commonJS({
       advertiseZstdAcceptEncoding: false,
       validateStatusUndefinedResolves: true
     };
-    var URLSearchParams = url.URLSearchParams;
+    var URLSearchParams2 = url.URLSearchParams;
     var ALPHA = "abcdefghijklmnopqrstuvwxyz";
     var DIGIT = "0123456789";
     var ALPHABET = {
@@ -61772,7 +61888,7 @@ var require_axios = __commonJS({
     var platform$1 = {
       isNode: true,
       classes: {
-        URLSearchParams,
+        URLSearchParams: URLSearchParams2,
         FormData: FormData$1,
         Blob: typeof Blob !== "undefined" && Blob || null
       },
@@ -65405,6 +65521,3998 @@ 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 resolvePreviousReceipt(config) {
+      const pr = config.previousReceipt;
+      if (pr === void 0 || pr === null)
+        return void 0;
+      let raw;
+      if (typeof pr === "function") {
+        try {
+          raw = pr();
+        } catch {
+          return void 0;
+        }
+      } else {
+        raw = pr;
+      }
+      if (typeof raw !== "string")
+        return void 0;
+      const s = raw.trim();
+      return s.length > 0 ? s : void 0;
+    }
+    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: resolvePreviousReceipt(config),
+        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/receipt-chain.js
+var require_receipt_chain = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/receipt-chain.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.RECEIPT_PREV_NULL = void 0;
+    exports2.previousReceiptCommitment = previousReceiptCommitment;
+    exports2.decodeReceiptBodyPrev = decodeReceiptBodyPrev;
+    exports2.verifyReceiptChainLinkage = verifyReceiptChainLinkage;
+    var node_crypto_1 = require("node:crypto");
+    exports2.RECEIPT_PREV_NULL = "null";
+    function previousReceiptCommitment(previousToken) {
+      return "sha256:" + (0, node_crypto_1.createHash)("sha256").update(previousToken, "utf8").digest("hex");
+    }
+    function decodeReceiptBodyPrev(token) {
+      if (typeof token !== "string" || token.length === 0)
+        return null;
+      const parts = token.split(".");
+      if (parts.length !== 2 || !parts[0] || !parts[1])
+        return null;
+      try {
+        const json = Buffer.from(parts[0], "base64url").toString("utf8");
+        const body = JSON.parse(json);
+        if (typeof body.prev !== "string")
+          return null;
+        return { prev: body.prev };
+      } catch {
+        return null;
+      }
+    }
+    function verifyReceiptChainLinkage(tokens) {
+      const length = tokens.length;
+      if (length === 0) {
+        return { ok: true, length: 0 };
+      }
+      for (let i = 0; i < length; i++) {
+        const decoded = decodeReceiptBodyPrev(tokens[i]);
+        if (!decoded) {
+          return {
+            ok: false,
+            length,
+            failedAt: i,
+            reason: "malformed_token"
+          };
+        }
+        if (i === 0) {
+          if (decoded.prev !== exports2.RECEIPT_PREV_NULL) {
+            return {
+              ok: false,
+              length,
+              failedAt: 0,
+              reason: "unexpected_predecessor",
+              expected: exports2.RECEIPT_PREV_NULL,
+              actual: decoded.prev
+            };
+          }
+          continue;
+        }
+        const expected = previousReceiptCommitment(tokens[i - 1]);
+        if (decoded.prev !== expected) {
+          return {
+            ok: false,
+            length,
+            failedAt: i,
+            reason: "broken_link",
+            expected,
+            actual: decoded.prev
+          };
+        }
+      }
+      return { ok: true, length };
+    }
+  }
+});
+
+// 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.classifyByName = classifyByName;
+    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 artifact_resolver_js_1 = require_artifact_resolver();
+    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) {
+      const d = { toolName: tool.name, arguments: args };
+      if (!args || typeof args !== "object")
+        return d;
+      const a = args;
+      if (Array.isArray(a.artifacts)) {
+        d.artifacts = a.artifacts;
+        return d;
+      }
+      const path = typeof a.path === "string" ? a.path : "";
+      if (!path)
+        return d;
+      const type = (0, artifact_resolver_js_1.classifyByName)(path);
+      if (!type)
+        return d;
+      const bothSides = (oldS, newS) => typeof oldS === "string" && oldS.length > 0 && typeof newS === "string" && newS.length > 0;
+      if (Array.isArray(a.edits)) {
+        const lifted = [];
+        for (let i = 0; i < a.edits.length; i++) {
+          const e = a.edits[i];
+          if (!e || typeof e !== "object")
+            continue;
+          const er = e;
+          if (!bothSides(er.old_string, er.new_string))
+            continue;
+          lifted.push({
+            id: `${type}:${path}#${i}`,
+            type,
+            before: er.old_string,
+            after: er.new_string
+          });
+        }
+        if (lifted.length > 0)
+          d.artifacts = lifted;
+        return d;
+      }
+      if (bothSides(a.old_string, a.new_string)) {
+        d.artifacts = [{
+          id: `${type}:${path}`,
+          type,
+          before: a.old_string,
+          after: a.new_string
+        }];
+      }
+      return d;
+    }
+    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";
+      } else {
+        if (protection.required_check_app_bound === true) {
+        } else if (protection.required_check_app_bound === false) {
+          residual = "required_check_app_not_bound";
+        } else {
+          residual = "required_check_app_binding_unknown";
+        }
+      }
+      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 = enforcement_state === "ENFORCING" || rc.require_bound_environment !== false;
+      const requireArt = enforcement_state === "ENFORCING" || 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/with-coderifts.js
+var require_with_coderifts = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/with-coderifts.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.withCodeRifts = withCodeRifts;
+    var tool_registry_js_1 = require_tool_registry();
+    var COMPOSITION_CALL_POLICY_COMPLETE = false;
+    var RESIDUAL_CALL_POLICY_INCOMPLETE = "composition_call_policy_incomplete";
+    var RESIDUAL_FORCED_READONLY = "composition_forced_readonly_on_heuristic_mutator";
+    var RESIDUAL_UNKNOWN_READONLY = "composition_unknown_treated_as_readonly";
+    var COVERAGE_STRENGTH = {
+      COMPLETE: 3,
+      PARTIAL: 2,
+      BYPASSED: 1,
+      UNKNOWN: 0
+    };
+    function coverageRank(coverage) {
+      return Object.prototype.hasOwnProperty.call(COVERAGE_STRENGTH, coverage) ? COVERAGE_STRENGTH[coverage] : void 0;
+    }
+    async function safeOnOutcome(onOutcome, payload) {
+      try {
+        await Promise.resolve(onOutcome(payload));
+      } catch {
+      }
+    }
+    function wrapGuardedForObservation(tool, onOutcome) {
+      const innerExecute = tool.execute;
+      const toolName = tool.name;
+      const shell = {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        meta: tool.meta,
+        _coderifts: tool._coderifts,
+        execute: async (args) => {
+          const outcome = await innerExecute(args);
+          await safeOnOutcome(onOutcome, {
+            toolName,
+            // Guarded execute always returns a GuardOutcome from guardToolCall; assert the type for callers.
+            outcome
+          });
+          return outcome;
+        }
+      };
+      if (!Object.isFrozen(shell._coderifts))
+        Object.freeze(shell._coderifts);
+      return Object.freeze(shell);
+    }
+    function withCodeRifts(input) {
+      if (!input || typeof input !== "object") {
+        throw new Error("withCodeRifts: input object is required");
+      }
+      const problems = [];
+      if (typeof input.operation !== "string" || input.operation.trim() === "") {
+        problems.push("`operation` is required and must be a non-empty string (receipts bind to an operation; merge != deploy, so there is no safe default)");
+      }
+      if (input.client == null) {
+        problems.push("`client` is required at construction (guardToolRegistry needs config.guard.client to wrap any mutating tool)");
+      }
+      if (input.requireCoverage !== void 0 && coverageRank(input.requireCoverage) === void 0) {
+        problems.push(`\`requireCoverage\` must be one of COMPLETE | PARTIAL | BYPASSED | UNKNOWN (got ${JSON.stringify(input.requireCoverage)})`);
+      }
+      if (problems.length > 0) {
+        throw new Error(`withCodeRifts: construction aborted \u2014 ${problems.length} condition(s):
+` + problems.map((p) => `  - ${p}`).join("\n"));
+      }
+      const reg = input.registry ?? {};
+      const guard = { client: input.client, operation: input.operation };
+      if (input.onEvent !== void 0) {
+        guard.onEvent = input.onEvent;
+      }
+      if (input.previousReceipt !== void 0) {
+        guard.previousReceipt = input.previousReceipt;
+      }
+      const config = {
+        guard,
+        unknownToolPolicy: reg.unknownToolPolicy ?? "mutating",
+        classify: reg.classify,
+        binders: reg.binders,
+        forceReadonly: reg.forceReadonly,
+        failOnUnguardedMutator: reg.failOnUnguardedMutator
+      };
+      const { tools, report } = (0, tool_registry_js_1.guardToolRegistry)(input.tools, config);
+      if (input.requireCoverage !== void 0) {
+        const requiredRank = coverageRank(input.requireCoverage);
+        const actualRank = coverageRank(report.coverage) ?? -1;
+        if (requiredRank !== void 0 && actualRank < requiredRank) {
+          throw new Error(`withCodeRifts: requireCoverage not met \u2014 registry coverage '${report.coverage}' is weaker than required '${input.requireCoverage}' (strength ordering COMPLETE > PARTIAL > BYPASSED > UNKNOWN). requireCoverage constrains the REGISTRY tool-boundary surface ONLY; a green construction here is NOT a product-level runtime-inescapability guarantee \u2014 composition_assurance.inescapable_runtime stays false until receipt carry-forward and a freshness-safe prior for write-style calls land.`);
+        }
+      }
+      const compositionInescapableRuntime = report.claim.inescapable_runtime && COMPOSITION_CALL_POLICY_COMPLETE;
+      const residuals = [RESIDUAL_CALL_POLICY_INCOMPLETE];
+      if (report.warnings.some((w) => w.startsWith("force_readonly_on_mutator_heuristic:"))) {
+        residuals.push(RESIDUAL_FORCED_READONLY);
+      }
+      if (report.warnings.includes("unknown_treated_as_readonly")) {
+        residuals.push(RESIDUAL_UNKNOWN_READONLY);
+      }
+      const composition_assurance = {
+        coverage: "PARTIAL",
+        inescapable_runtime: compositionInescapableRuntime,
+        residuals
+      };
+      let toolsOut = tools;
+      if (input.onOutcome) {
+        const onOutcome = input.onOutcome;
+        toolsOut = Object.freeze(tools.map((t) => t._coderifts.guarded ? wrapGuardedForObservation(t, onOutcome) : t));
+      }
+      const result = {
+        tools: toolsOut,
+        registry_report: report,
+        composition_assurance
+      };
+      if (input.repository !== void 0)
+        result.repository = input.repository;
+      return result;
+    }
+  }
+});
+
+// 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.withCodeRifts = exports2.coverageReport = exports2.deployGate = exports2.gateDecision = exports2.RegistryConstructionError = exports2.guardToolRegistry = exports2.globToRegExp = exports2.matchGlob = exports2.classifyByName = 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.RECEIPT_PREV_NULL = exports2.decodeReceiptBodyPrev = exports2.previousReceiptCommitment = exports2.verifyReceiptChainLinkage = 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 receipt_chain_js_1 = require_receipt_chain();
+    Object.defineProperty(exports2, "verifyReceiptChainLinkage", { enumerable: true, get: function() {
+      return receipt_chain_js_1.verifyReceiptChainLinkage;
+    } });
+    Object.defineProperty(exports2, "previousReceiptCommitment", { enumerable: true, get: function() {
+      return receipt_chain_js_1.previousReceiptCommitment;
+    } });
+    Object.defineProperty(exports2, "decodeReceiptBodyPrev", { enumerable: true, get: function() {
+      return receipt_chain_js_1.decodeReceiptBodyPrev;
+    } });
+    Object.defineProperty(exports2, "RECEIPT_PREV_NULL", { enumerable: true, get: function() {
+      return receipt_chain_js_1.RECEIPT_PREV_NULL;
+    } });
+    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;
+    } });
+    Object.defineProperty(exports2, "classifyByName", { enumerable: true, get: function() {
+      return artifact_resolver_js_1.classifyByName;
+    } });
+    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;
+    } });
+    var with_coderifts_js_1 = require_with_coderifts();
+    Object.defineProperty(exports2, "withCodeRifts", { enumerable: true, get: function() {
+      return with_coderifts_js_1.withCodeRifts;
+    } });
+  }
+});
+
+// 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/publish-gate.js
+var require_publish_gate = __commonJS({
+  "src/commands/publish-gate.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var { execFileSync } = require("child_process");
+    var chalk = require_source();
+    var { getApiKey } = require_config();
+    var { cloudDiff } = require_cloud();
+    if (process.env.NO_COLOR) chalk.level = 0;
+    var ZERO_SHA = "0000000000000000000000000000000000000000";
+    var CLOSED_ACTIONS = /* @__PURE__ */ new Set([
+      "CONTINUE",
+      "CONTINUE_WITH_MONITORING",
+      "REQUEST_APPROVAL",
+      "STOP"
+    ]);
+    var PERMIT_ACTIONS = /* @__PURE__ */ new Set(["CONTINUE", "CONTINUE_WITH_MONITORING"]);
+    function defaultGit(args, cwd) {
+      return execFileSync("git", args, {
+        cwd: cwd || process.cwd(),
+        encoding: "utf8",
+        maxBuffer: 16 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "pipe"]
+      }).trim();
+    }
+    function gitShow(ref, filePath, { gitImpl = defaultGit, cwd } = {}) {
+      try {
+        const out = gitImpl(["show", `${ref}:${filePath}`], cwd);
+        return { ok: true, content: out == null ? "" : String(out) };
+      } catch (err) {
+        const msg = err && err.stderr ? String(err.stderr) : err && err.message || String(err);
+        return {
+          ok: false,
+          code: "GIT_ERROR",
+          message: `git error reading ${ref}:${filePath}: ${msg.slice(0, 300)}`
+        };
+      }
+    }
+    function readPackageVersion(cwd, readFile = fs.readFileSync) {
+      const pkgPath = path.join(cwd || process.cwd(), "package.json");
+      try {
+        const raw = readFile(pkgPath, "utf8");
+        const pkg2 = JSON.parse(raw);
+        return pkg2 && typeof pkg2.version === "string" ? pkg2.version : null;
+      } catch {
+        return null;
+      }
+    }
+    function resolveBeforeSpec(specPath, {
+      gitImpl = defaultGit,
+      cwd = process.cwd(),
+      readFile = fs.readFileSync,
+      packageVersion = null
+    } = {}) {
+      const version = packageVersion != null ? packageVersion : readPackageVersion(cwd, readFile);
+      const tried = [];
+      if (version) {
+        const tags = [`v${version}`, version];
+        for (const tag of tags) {
+          tried.push(`tag:${tag}`);
+          try {
+            gitImpl(["rev-parse", "--verify", `${tag}^{commit}`], cwd);
+          } catch {
+            continue;
+          }
+          const shown = gitShow(tag, specPath, { gitImpl, cwd });
+          if (!shown.ok) {
+            return {
+              ok: false,
+              code: shown.code || "GIT_ERROR",
+              message: shown.message,
+              tried
+            };
+          }
+          if (shown.content.trim() === "") {
+            return {
+              ok: false,
+              code: "EMPTY_BEFORE",
+              message: `Empty contract artifact at tag ${tag}:${specPath}. Refusing to treat empty before as NEW_ARTIFACT (would false-pass enforce).`,
+              tried
+            };
+          }
+          return { ok: true, content: shown.content, source: `tag:${tag}`, tried };
+        }
+      } else {
+        tried.push("package.json:version (missing)");
+      }
+      const bases = ["origin/main", "origin/master", "main", "master"];
+      for (const base of bases) {
+        tried.push(`merge-base:${base}`);
+        let mb;
+        try {
+          mb = gitImpl(["merge-base", "HEAD", base], cwd);
+        } catch {
+          continue;
+        }
+        if (!mb || mb === ZERO_SHA) continue;
+        const shown = gitShow(mb, specPath, { gitImpl, cwd });
+        if (!shown.ok) {
+          return {
+            ok: false,
+            code: shown.code || "GIT_ERROR",
+            message: shown.message,
+            tried
+          };
+        }
+        if (shown.content.trim() === "") {
+          return {
+            ok: false,
+            code: "EMPTY_BEFORE",
+            message: `Empty contract artifact at merge-base ${mb}:${specPath} (${base}). Refusing to treat empty before as NEW_ARTIFACT (would false-pass enforce).`,
+            tried
+          };
+        }
+        return {
+          ok: true,
+          content: shown.content,
+          source: `merge-base:${base}@${mb.slice(0, 12)}`,
+          tried
+        };
+      }
+      return {
+        ok: false,
+        code: "BEFORE_UNRESOLVED",
+        message: `Could not resolve a non-empty before-spec for ${specPath}. Tried: (a) git tag of package.json version, (b) merge-base with origin/main. Attempts: ${tried.join(", ")}. Fail-closed \u2014 will not publish without a baseline.`,
+        tried
+      };
+    }
+    function resolveAfterSpec(specPath, {
+      cwd = process.cwd(),
+      readFile = fs.readFileSync,
+      exists = fs.existsSync
+    } = {}) {
+      const resolved = path.isAbsolute(specPath) ? specPath : path.join(cwd, specPath);
+      try {
+        if (!exists(resolved)) {
+          return {
+            ok: false,
+            code: "AFTER_MISSING",
+            message: `Working-tree contract artifact not found: ${specPath}`
+          };
+        }
+        const content = readFile(resolved, "utf8");
+        if (content == null || String(content).trim() === "") {
+          return {
+            ok: false,
+            code: "AFTER_EMPTY",
+            message: `Working-tree contract artifact is empty: ${specPath}`
+          };
+        }
+        return { ok: true, content: String(content), path: resolved };
+      } catch (err) {
+        return {
+          ok: false,
+          code: "AFTER_READ_ERROR",
+          message: `Failed to read working-tree ${specPath}: ${err && err.message}`
+        };
+      }
+    }
+    function evaluatePublishPermission(result) {
+      if (!result || typeof result !== "object") {
+        return {
+          allow: false,
+          execution_action: null,
+          decision: null,
+          policy: "fail_closed:unreadable_response"
+        };
+      }
+      const env = result.decision_result && typeof result.decision_result === "object" ? result.decision_result : null;
+      let ea = null;
+      if (env && typeof env.execution_action === "string") ea = env.execution_action;
+      else if (typeof result.execution_action === "string") ea = result.execution_action;
+      const decision = env && env.decision || result.decision || result.omega_decision || null;
+      if (ea && CLOSED_ACTIONS.has(ea)) {
+        const allow = PERMIT_ACTIONS.has(ea);
+        return {
+          allow,
+          execution_action: ea,
+          decision: decision || null,
+          policy: allow ? `permit:execution_action=${ea}` : `block:execution_action=${ea}`
+        };
+      }
+      if (ea != null && ea !== "" && !CLOSED_ACTIONS.has(ea)) {
+        return {
+          allow: false,
+          execution_action: ea,
+          decision: decision || null,
+          policy: `block:unrecognised_execution_action=${ea}`
+        };
+      }
+      if (decision === "BLOCK" || decision === "REQUIRE_APPROVAL") {
+        return {
+          allow: false,
+          execution_action: null,
+          decision,
+          policy: `block:decision=${decision}`
+        };
+      }
+      if (decision === "ALLOW" || decision === "WARN" || decision === "PASS") {
+        return {
+          allow: true,
+          execution_action: null,
+          decision,
+          policy: `permit:decision=${decision}`
+        };
+      }
+      const omega = result.omega_decision;
+      if (omega === "BLOCK" || omega === "REQUIRE_APPROVAL") {
+        return {
+          allow: false,
+          execution_action: null,
+          decision: omega,
+          policy: `block:omega_decision=${omega}`
+        };
+      }
+      return {
+        allow: false,
+        execution_action: ea,
+        decision: decision || omega || null,
+        policy: "fail_closed:no_permission_signal"
+      };
+    }
+    function extractReceiptRef(result) {
+      if (!result || typeof result !== "object") return null;
+      const env = result.decision_result;
+      if (env && env.receipt && typeof env.receipt.token === "string") {
+        return env.receipt.token.slice(0, 24) + (env.receipt.token.length > 24 ? "\u2026" : "");
+      }
+      if (env && typeof env.decision_id === "string") return env.decision_id;
+      if (typeof result.decision_id === "string") return result.decision_id;
+      if (typeof result.fingerprint === "string") return result.fingerprint;
+      if (env && typeof env.fingerprint === "string") return env.fingerprint;
+      return null;
+    }
+    async function defaultPreflight(before, after, { apiKey } = {}) {
+      const key = process.env.CODERIFTS_FORCE_LOCAL_PREFLIGHT ? null : apiKey != null ? apiKey : getApiKey();
+      if (key) {
+        return cloudDiff(before, after, key);
+      }
+      const yaml = require_js_yaml();
+      const { diffSpecs } = require_api2();
+      let oldSpec;
+      let newSpec;
+      try {
+        oldSpec = yaml.load(before);
+        newSpec = yaml.load(after);
+      } catch (e) {
+        const err = new Error(`Failed to parse specs: ${e.message}`);
+        err.code = "PREFLIGHT_UNREACHABLE";
+        throw err;
+      }
+      let diffResult;
+      try {
+        diffResult = await diffSpecs({
+          sourceSpec: { content: JSON.stringify(oldSpec), location: "before.json", format: "openapi3" },
+          destinationSpec: { content: JSON.stringify(newSpec), location: "after.json", format: "openapi3" }
+        });
+      } catch (e) {
+        const err = new Error(`Local preflight engine error: ${e.message}`);
+        err.code = "PREFLIGHT_UNREACHABLE";
+        throw err;
+      }
+      const breaking = (diffResult.breakingDifferences || []).length;
+      const decision = breaking > 0 ? "BLOCK" : "ALLOW";
+      const execution_action = breaking > 0 ? "STOP" : "CONTINUE";
+      return {
+        decision,
+        omega_decision: decision,
+        execution_action,
+        decision_result: {
+          decision,
+          execution_action,
+          decision_id: `local-${Date.now()}`
+        },
+        breaking_changes: diffResult.breakingDifferences || [],
+        risk_score: Math.min(breaking * 15, 100)
+      };
+    }
+    async function runPublishGate(options = {}, deps = {}) {
+      const cwd = deps.cwd || process.cwd();
+      const gitImpl = deps.gitImpl || defaultGit;
+      const readFile = deps.readFile || fs.readFileSync.bind(fs);
+      const exists = deps.exists || fs.existsSync.bind(fs);
+      const preflightFn = deps.preflightFn || defaultPreflight;
+      const log = deps.log || console.log.bind(console);
+      const logErr = deps.logErr || console.error.bind(console);
+      let specPath = options.spec;
+      if (!specPath) {
+        try {
+          specPath = gitImpl(["config", "coderifts.specPath"], cwd);
+        } catch {
+          specPath = "";
+        }
+      }
+      if (!specPath) specPath = "api/openapi.yaml";
+      try {
+        gitImpl(["rev-parse", "--is-inside-work-tree"], cwd);
+      } catch (err) {
+        const msg = "CodeRifts publish-gate: GIT_ERROR \u2014 not a git repository (or git unavailable). Cannot resolve before-spec without git. Fail-closed.";
+        logErr(chalk.red(msg));
+        return finish({
+          ok: false,
+          exitCode: 1,
+          code: "GIT_ERROR",
+          message: msg,
+          policy: "fail_closed:git_error"
+        }, { log, json: options.json });
+      }
+      const beforeRes = resolveBeforeSpec(specPath, {
+        gitImpl,
+        cwd,
+        readFile,
+        packageVersion: deps.packageVersion
+      });
+      if (!beforeRes.ok) {
+        logErr(chalk.red(`CodeRifts publish-gate: ${beforeRes.code} \u2014 ${beforeRes.message}`));
+        return finish({
+          ok: false,
+          exitCode: 1,
+          code: beforeRes.code,
+          message: beforeRes.message,
+          policy: `fail_closed:${beforeRes.code}`,
+          tried: beforeRes.tried
+        }, { log, json: options.json });
+      }
+      const afterRes = resolveAfterSpec(specPath, { cwd, readFile, exists });
+      if (!afterRes.ok) {
+        logErr(chalk.red(`CodeRifts publish-gate: ${afterRes.code} \u2014 ${afterRes.message}`));
+        return finish({
+          ok: false,
+          exitCode: 1,
+          code: afterRes.code,
+          message: afterRes.message,
+          policy: `fail_closed:${afterRes.code}`
+        }, { log, json: options.json });
+      }
+      if (beforeRes.content === afterRes.content) {
+        const payload2 = {
+          ok: true,
+          exitCode: 0,
+          code: "UNCHANGED",
+          message: "Contract artifact unchanged vs baseline; publish permitted.",
+          policy: "permit:unchanged",
+          before_source: beforeRes.source,
+          execution_action: "CONTINUE",
+          receipt: null
+        };
+        if (!options.json) {
+          log(chalk.green("CodeRifts publish-gate: ALLOW (unchanged)"));
+          log(`  baseline: ${beforeRes.source}`);
+          log(`  spec:     ${specPath}`);
+        }
+        return finish(payload2, { log, json: options.json });
+      }
+      let result;
+      try {
+        result = await preflightFn(beforeRes.content, afterRes.content, {
+          apiKey: deps.apiKey,
+          cwd
+        });
+      } catch (err) {
+        const msg = `CodeRifts publish-gate: PREFLIGHT_UNREACHABLE \u2014 ${err && err.message}`;
+        logErr(chalk.red(msg));
+        return finish({
+          ok: false,
+          exitCode: 1,
+          code: "PREFLIGHT_UNREACHABLE",
+          message: msg,
+          policy: "fail_closed:preflight_unreachable"
+        }, { log, json: options.json });
+      }
+      const perm = evaluatePublishPermission(result);
+      const receipt = extractReceiptRef(result);
+      if (!perm.allow) {
+        const payload2 = {
+          ok: false,
+          exitCode: 1,
+          code: "BLOCK",
+          message: "Publish not permitted by execution_action / decision.",
+          policy: perm.policy,
+          execution_action: perm.execution_action,
+          decision: perm.decision,
+          before_source: beforeRes.source,
+          receipt,
+          fail_policy: "exit_1_on_block_or_resolver_error_or_unreachable"
+        };
+        if (!options.json) {
+          logErr("");
+          logErr(chalk.red("========================================"));
+          logErr(chalk.red("  CodeRifts: PUBLISH BLOCKED"));
+          logErr(chalk.red("========================================"));
+          logErr(`  Policy:            ${perm.policy}`);
+          logErr(`  execution_action:  ${perm.execution_action || "(none)"}`);
+          logErr(`  decision:          ${perm.decision || "(none)"}`);
+          logErr(`  baseline:          ${beforeRes.source}`);
+          logErr(`  fail policy:       exit 1 on BLOCK / resolver error / preflight unreachability`);
+          logErr(chalk.red("========================================"));
+          logErr("");
+        }
+        return finish(payload2, { log, json: options.json });
+      }
+      const payload = {
+        ok: true,
+        exitCode: 0,
+        code: "ALLOW",
+        message: "Publish permitted.",
+        policy: perm.policy,
+        execution_action: perm.execution_action,
+        decision: perm.decision,
+        before_source: beforeRes.source,
+        receipt
+      };
+      if (!options.json) {
+        log(chalk.green("CodeRifts publish-gate: ALLOW"));
+        log(`  Policy:            ${perm.policy}`);
+        log(`  execution_action:  ${perm.execution_action || "(mapped from decision)"}`);
+        log(`  baseline:          ${beforeRes.source}`);
+        if (receipt) log(`  Receipt reference: ${receipt}`);
+        else log("  Receipt reference: (none issued on this path)");
+      }
+      return finish(payload, { log, json: options.json });
+    }
+    function finish(payload, { log, json }) {
+      if (json) {
+        log(JSON.stringify(payload, null, 2));
+      }
+      return payload;
+    }
+    module2.exports = {
+      runPublishGate,
+      resolveBeforeSpec,
+      resolveAfterSpec,
+      evaluatePublishPermission,
+      extractReceiptRef,
+      gitShow,
+      defaultGit,
+      PERMIT_ACTIONS,
+      CLOSED_ACTIONS
+    };
+  }
+});
+
 // src/commands/init.js
 var require_init = __commonJS({
   "src/commands/init.js"(exports2, module2) {
@@ -76068,7 +80176,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) {
@@ -77385,7 +81493,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") {
@@ -77410,7 +81518,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();
@@ -80124,7 +84232,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 || {} };
@@ -90922,7 +95030,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
@@ -91093,6 +95201,8 @@ ${HOOK_MARKER}
 # Checks API spec changes before pushing.
 # The pre-push hook receives lines on stdin:
 #   <local ref> <local sha> <remote ref> <remote sha>
+#
+# Re-install after CLI upgrades: coderifts hook install
 
 CODERIFTS_API_KEY=$(git config coderifts.apiKey)
 SPEC_PATH=$(git config coderifts.specPath || echo "api/openapi.yaml")
@@ -91103,6 +95213,53 @@ if [ -z "$CODERIFTS_API_KEY" ]; then
   exit 0  # Don't block if not configured
 fi
 
+# --- helpers: three-state git blob read (present | absent | error) ---
+# Sets: BLOB_KIND, BLOB_CONTENT, BLOB_ERR. Never maps unreadable \u2192 empty string.
+git_blob_at() {
+  _ref="$1"
+  _path="$2"
+  BLOB_CONTENT=""
+  BLOB_ERR=""
+  BLOB_KIND=""
+  if ! git rev-parse --verify "$_ref^{commit}" >/dev/null 2>&1; then
+    BLOB_KIND=error
+    BLOB_ERR="GIT_ERROR: cannot resolve ref $_ref"
+    return 1
+  fi
+  _errf=$(mktemp 2>/dev/null || echo "/tmp/coderifts-hook-err.$$")
+  if BLOB_CONTENT=$(git show "$_ref:$_path" 2>"$_errf"); then
+    BLOB_KIND=present
+    rm -f "$_errf"
+    return 0
+  fi
+  _err=$(cat "$_errf" 2>/dev/null)
+  rm -f "$_errf"
+  case "$_err" in
+    *"does not exist in"*|*"exists on disk, but not in"*)
+      BLOB_KIND=absent
+      BLOB_CONTENT=""
+      return 0
+      ;;
+  esac
+  BLOB_KIND=error
+  BLOB_ERR="GIT_ERROR: git show $_ref:$_path failed"
+  return 1
+}
+
+# New-branch baseline: merge-base with default branch (not empty before).
+# Prints merge-base SHA on success; nonzero if none can be resolved.
+resolve_new_branch_base_ref() {
+  _local="$1"
+  for _cand in origin/HEAD origin/main origin/master main master; do
+    _mb=$(git merge-base "$_local" "$_cand" 2>/dev/null) || continue
+    if [ -n "$_mb" ] && [ "$_mb" != "$ZERO" ]; then
+      echo "$_mb"
+      return 0
+    fi
+  done
+  return 1
+}
+
 # Read stdin lines provided by git pre-push
 while read LOCAL_REF LOCAL_SHA REMOTE_REF REMOTE_SHA; do
   # Skip delete pushes
@@ -91110,41 +95267,93 @@ while read LOCAL_REF LOCAL_SHA REMOTE_REF REMOTE_SHA; do
     continue
   fi
 
-  # Get the spec at the local (about-to-be-pushed) commit
-  HEAD_SPEC=$(git show "$LOCAL_SHA:$SPEC_PATH" 2>/dev/null)
-  if [ -z "$HEAD_SPEC" ]; then
+  # after = local (about-to-be-pushed) commit \u2014 three-state
+  if ! git_blob_at "$LOCAL_SHA" "$SPEC_PATH"; then
+    echo "CodeRifts: $BLOB_ERR (after=$SPEC_PATH at $LOCAL_SHA). Fail-closed."
+    exit 1
+  fi
+  if [ "$BLOB_KIND" = "absent" ]; then
     continue  # Spec doesn't exist in local commit, skip
   fi
+  HEAD_SPEC=$BLOB_CONTENT
 
-  # Get the spec at the remote (already-pushed) commit
+  # before = remote tip, or for new branch (zero remote SHA) a merge-base baseline
   if [ "$REMOTE_SHA" = "$ZERO" ]; then
-    # New branch \u2014 no remote baseline, use empty spec
-    BASE_SPEC=""
+    BASE_REF=$(resolve_new_branch_base_ref "$LOCAL_SHA") || {
+      echo "CodeRifts: GIT_ERROR \u2014 cannot resolve merge-base baseline for new branch (tried origin/HEAD, origin/main, origin/master, main, master). Fail-closed."
+      exit 1
+    }
   else
-    BASE_SPEC=$(git show "$REMOTE_SHA:$SPEC_PATH" 2>/dev/null || echo "")
+    BASE_REF=$REMOTE_SHA
   fi
 
-  # If base is empty (new spec or new branch), allow
-  if [ -z "$BASE_SPEC" ]; then
-    echo "CodeRifts: New spec detected, allowing push."
+  if ! git_blob_at "$BASE_REF" "$SPEC_PATH"; then
+    echo "CodeRifts: $BLOB_ERR (before=$SPEC_PATH at $BASE_REF). Fail-closed \u2014 not treating as new spec."
+    exit 1
+  fi
+  if [ "$BLOB_KIND" = "absent" ]; then
+    # Honest NEW_ARTIFACT: path genuinely not at baseline
+    echo "CodeRifts: New artifact (spec absent at baseline $BASE_REF:$SPEC_PATH); allowing push."
     continue
   fi
+  BASE_SPEC=$BLOB_CONTENT
 
   # If specs are identical, nothing to check
   if [ "$BASE_SPEC" = "$HEAD_SPEC" ]; then
     continue
   fi
 
-  echo "CodeRifts: Checking API spec changes..."
+  echo "CodeRifts: Checking API spec changes (baseline $BASE_REF)..."
 
   RESULT=$(curl -s -X POST https://app.coderifts.com/api/v1/diff \\
     -H "Authorization: Bearer $CODERIFTS_API_KEY" \\
     -H "Content-Type: application/json" \\
     -d "{\\"before\\": $(echo "$BASE_SPEC" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read()))'), \\"after\\": $(echo "$HEAD_SPEC" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read()))')}")
 
-  DECISION=$(echo $RESULT | python3 -c "import sys,json; print(json.load(sys.stdin).get('omega_decision','ALLOW'))" 2>/dev/null)
-  OMEGA=$(echo $RESULT | python3 -c "import sys,json; print(json.load(sys.stdin).get('omega_api',0))" 2>/dev/null)
-  BREAKING=$(echo $RESULT | python3 -c "import sys,json; d=json.load(sys.stdin); print(len(d.get('breaking_changes',[])))" 2>/dev/null)
+  # Prefer closed-set execution_action; omega_decision only when action is absent.
+  # Severity (unchanged): BLOCK/STOP \u2192 exit 1; REQUIRE_APPROVAL/WARN \u2192 warn; unknown action \u2192 halt.
+  DECISION=$(echo "$RESULT" | python3 -c '
+import sys, json
+try:
+    d = json.load(sys.stdin)
+except Exception:
+    print("ALLOW")
+    raise SystemExit(0)
+ea = None
+dr = d.get("decision_result")
+if isinstance(dr, dict) and isinstance(dr.get("execution_action"), str):
+    ea = dr["execution_action"]
+elif isinstance(d.get("execution_action"), str):
+    ea = d["execution_action"]
+closed = {"CONTINUE", "CONTINUE_WITH_MONITORING", "REQUEST_APPROVAL", "STOP"}
+if ea is not None and ea != "":
+    if ea not in closed:
+        print("UNKNOWN")
+        raise SystemExit(0)
+    if ea in ("CONTINUE", "CONTINUE_WITH_MONITORING"):
+        print("ALLOW")
+    elif ea == "STOP":
+        print("BLOCK")
+    else:
+        print("REQUIRE_APPROVAL")
+    raise SystemExit(0)
+od = d.get("omega_decision") or d.get("decision") or "ALLOW"
+print(od)
+' 2>/dev/null)
+  OMEGA=$(echo "$RESULT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('omega_api',0))" 2>/dev/null)
+  BREAKING=$(echo "$RESULT" | python3 -c "import sys,json; d=json.load(sys.stdin); print(len(d.get('breaking_changes',[])))" 2>/dev/null)
+
+  if [ "$DECISION" = "UNKNOWN" ]; then
+    echo ""
+    echo "========================================"
+    echo "  CodeRifts: PUSH BLOCKED"
+    echo "========================================"
+    echo "  Reason: unrecognised execution_action is not permission"
+    echo "  Fail-closed (unknown present action)."
+    echo "========================================"
+    echo ""
+    exit 1
+  fi
 
   if [ "$DECISION" = "BLOCK" ]; then
     echo ""
@@ -91212,6 +95421,10 @@ exit 0
       console.log("");
       console.log("Optionally set spec path (default: api/openapi.yaml):");
       console.log("  git config coderifts.specPath path/to/openapi.yaml");
+      console.log("");
+      console.log("After upgrading the coderifts CLI, re-run this command so the installed");
+      console.log("hook matches the package (already-installed hooks are not auto-updated):");
+      console.log("  coderifts hook install");
     }
     function uninstall() {
       const gitDir = findGitDir();
@@ -92581,6 +96794,7 @@ var require_mcp_poisoning_detector = __commonJS({
   "../../src/mcp-poisoning-detector.js"(exports2, module2) {
     "use strict";
     var SENSITIVE_OBJECT = "(secrets?|credentials?|tokens?|passwords?|api[\\s_-]?keys?|private[\\s_-]?keys?|env|environment|conversation|chat\\s*history|context|user\\s*data|session)";
+    var SENSITIVE_SCOPE = "(any|all|every|stored|user\\'?s?|the\\s+user\\'?s?|all\\s+environment)";
     var SUSPICIOUS_PATTERNS = [
       // Injection / "ignore your instructions" family. The trailing object
       // (instructions|rules|prompts|context) is OPTIONAL so "ignore previous and ..."
@@ -92593,6 +96807,21 @@ var require_mcp_poisoning_detector = __commonJS({
       /exfiltrate|steal|leak|send\s+to\s+external/i,
       // Exfiltration-intent family: an action verb targeting a sensitive payload.
       /\b(send|forward|copy|upload|post|transmit|exfiltrate|leak)\b[\s\S]{0,40}?\b(conversation|chat|history|context|messages?|credentials?|secrets?|tokens?|api\s*keys?|keys?|passwords?|data)\b/i,
+      // Return/echo scoped sensitive material without a path ("return any stored credentials").
+      // Scope word required — bare "return the new API token" must stay quiet.
+      new RegExp(
+        "\\b(return|echo|reveal|expose|send)\\b[\\s\\S]{0,30}?\\b" + SENSITIVE_SCOPE + "\\s+(secrets?|credentials?|tokens?|passwords?|private[\\s_-]?keys?|environment\\s+variables?|env)\\b",
+        "i"
+      ),
+      // Retrieve private-key material + echo/return (intent without a filesystem path).
+      // Narrow: requires both a retrieve-class verb and an echo/return/reveal verb around key material.
+      /\b(retrieve|fetch|extract|obtain|collect)\b[\s\S]{0,60}?\b(private[\s_-]?keys?(?:\s+material)?|secret[\s_-]?keys?|key\s+material)\b[\s\S]{0,50}?\b(echo|return|send|reveal|expose)\b/i,
+      // Outbound destination without a named secret: exfil-shaped phrasing + http(s) URL.
+      // Bare URL alone stays quiet (legit tools reference docs / configured webhook URLs).
+      // "Sends the result to https://hooks…" (tool purpose) must NOT fire — requires "a copy"
+      // or "also send" as the exfil marker, not mere "send … to <url>".
+      /\b(send|forward|post|upload|transmit)\s+a\s+copy\b[\s\S]{0,50}?https?:\/\//i,
+      /\balso\s+send\b[\s\S]{0,60}?https?:\/\//i,
       /execute\s+(shell|command|code|system)/i,
       /bypass\s+(auth|security|validation|filter)/i,
       /override\s+(safety|policy|rules?)/i,
@@ -92604,8 +96833,8 @@ var require_mcp_poisoning_detector = __commonJS({
       /return\s+secret|exfiltrat|leak\s+data/i
     ];
     var URL_PATTERN = /https?:\/\/[^\s)'"]+/i;
-    var SENSITIVE_PATH_PATTERN = /(~\/\.ssh|~\/\.cursor|~\/\.aws|\.aws\/|\.env\b|\/etc\/|mcp\.json|credentials|id_rsa|\.ssh\/|private[\s_-]?keys?)/i;
-    var CONTENT_MOVE_VERB_PATTERN = /\b(pass|send|return|forward|include|read|upload|post|transmit|copy|exfiltrate|leak)\b/i;
+    var SENSITIVE_PATH_PATTERN = /(~\/\.ssh|~\/\.cursor|~\/\.aws|\.aws\/|\.env\b|\/etc\/|mcp\.json|id_rsa|\.ssh\/|\/credentials(?:\.|\/)|credentials\.(?:json|txt|pem|env)|\.credentials\b)/i;
+    var CONTENT_MOVE_VERB_PATTERN = /\b(pass|send|return|forward|include|read|upload|post|transmit|copy|exfiltrate|leak|echo|reveal|expose)\b/i;
     var BASE64_BLOB_PATTERN = /[A-Za-z0-9+/]{40,}={0,2}/;
     function isLikelyBase64(s) {
       if (/=$/.test(s)) return true;
@@ -93140,6 +97369,17 @@ 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("publish-gate").description("Gate npm publish on contract-artifact preflight (before=git baseline, after=working tree)").option("--spec <path>", "Contract artifact path (default: git config coderifts.specPath or api/openapi.yaml)").option("--json", "Machine-readable JSON result").action(async (options) => {
+  const { runPublishGate } = require_publish_gate();
+  const result = await runPublishGate(options);
+  const code = result && typeof result.exitCode === "number" ? result.exitCode : 1;
+  process.exitCode = code;
+  process.exit(code);
+});
 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);
@@ -93166,7 +97406,11 @@ corpusCmd.command("verify", { isDefault: true }).description("Evaluate every tru
   const { corpusVerify } = require_corpus();
   corpusVerify(options);
 });
-program.parse();
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err);
+  process.exitCode = typeof process.exitCode === "number" && process.exitCode !== 0 ? process.exitCode : 1;
+  process.exit(process.exitCode);
+});
 /*! Bundled license information:
 
 safe-buffer/index.js: