coderifts 1.8.4 → 1.9.0

package/dist/cli.js

@@ -3007,7 +3007,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "coderifts",
-      version: "1.8.4",
+      version: "1.9.0",
       description: "Detect breaking API changes from the command line. Works locally or with the CodeRifts cloud API.",
       author: "CodeRifts <hello@coderifts.com>",
       license: "MIT",
@@ -3050,6 +3050,7 @@ var require_package = __commonJS({
         test: "node --test test/*.test.js"
       },
       dependencies: {
+        "@coderifts/agent-guard": "^1.6.0",
         chalk: "^4.1.2",
         "cli-table3": "^0.6.4",
         commander: "^12.0.0",
@@ -61749,7 +61750,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 +61773,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 +65406,3267 @@ var require_diff = __commonJS({
   }
 });
 
+// ../../node_modules/@coderifts/sdk/dist/cjs/errors.js
+var require_errors5 = __commonJS({
+  "../../node_modules/@coderifts/sdk/dist/cjs/errors.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.AuthError = exports2.RateLimitError = exports2.TimeoutError = exports2.ApiError = exports2.CodeRiftsError = void 0;
+    var CodeRiftsError = class extends Error {
+      code;
+      constructor(message, code = "unknown") {
+        super(message);
+        this.name = "CodeRiftsError";
+        this.code = code;
+      }
+    };
+    exports2.CodeRiftsError = CodeRiftsError;
+    var ApiError = class extends CodeRiftsError {
+      status;
+      code;
+      body;
+      constructor(status, body) {
+        super(`[${status}] ${body.error}: ${body.message}`);
+        this.name = "ApiError";
+        this.status = status;
+        this.code = body.error;
+        this.body = body;
+      }
+    };
+    exports2.ApiError = ApiError;
+    var TimeoutError = class extends CodeRiftsError {
+      constructor(timeoutMs) {
+        super(`Request timed out after ${timeoutMs}ms`);
+        this.name = "TimeoutError";
+      }
+    };
+    exports2.TimeoutError = TimeoutError;
+    var RateLimitError = class extends ApiError {
+      constructor(body) {
+        super(429, body);
+        this.name = "RateLimitError";
+      }
+    };
+    exports2.RateLimitError = RateLimitError;
+    var AuthError = class extends ApiError {
+      constructor(body) {
+        super(401, body);
+        this.name = "AuthError";
+      }
+    };
+    exports2.AuthError = AuthError;
+  }
+});
+
+// ../../node_modules/@coderifts/sdk/dist/cjs/client.js
+var require_client = __commonJS({
+  "../../node_modules/@coderifts/sdk/dist/cjs/client.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CodeRifts = void 0;
+    var errors_js_1 = require_errors5();
+    var DEFAULT_BASE_URL = "https://app.coderifts.com";
+    var DEFAULT_TIMEOUT = 3e4;
+    var CodeRifts = class {
+      apiKey;
+      baseUrl;
+      timeout;
+      constructor(options) {
+        if (!options.apiKey) {
+          throw new Error("apiKey is required");
+        }
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+        this.timeout = options.timeout || DEFAULT_TIMEOUT;
+      }
+      // ─── Internal HTTP helper ──────────────────────────────────────────────
+      async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const res = await fetch(url, {
+            method,
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${this.apiKey}`
+            },
+            body: body ? JSON.stringify(body) : void 0,
+            signal: controller.signal
+          });
+          const json = await res.json();
+          if (!res.ok) {
+            const errorBody = {
+              error: json.error || "unknown",
+              message: json.message || res.statusText
+            };
+            if (res.status === 401)
+              throw new errors_js_1.AuthError(errorBody);
+            if (res.status === 429)
+              throw new errors_js_1.RateLimitError(errorBody);
+            throw new errors_js_1.ApiError(res.status, errorBody);
+          }
+          return json;
+        } catch (err) {
+          if (err instanceof errors_js_1.ApiError)
+            throw err;
+          if (err.name === "AbortError") {
+            throw new errors_js_1.TimeoutError(this.timeout);
+          }
+          throw err;
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+      // ─── 1. preflightCheck ─────────────────────────────────────────────────
+      /**
+       * Check whether it is safe to proceed with a tool invocation.
+       *
+       * Accepts `old_spec` / `new_spec` (OpenAPI YAML strings) and a `tool_name`.
+       * The SDK converts the specs to MCP tool arrays and calls POST /api/v1/agent/preflight.
+       */
+      async preflightCheck(req) {
+        const raw = await this.request("POST", "/api/v1/agent/preflight", {
+          tool_name: req.tool_name,
+          old_spec: req.old_spec,
+          new_spec: req.new_spec
+        });
+        const decision = raw.decision || "ALLOW";
+        return {
+          decision,
+          omega_api: raw.omega_api ?? 0,
+          safe: decision === "ALLOW" || decision === "WARN",
+          reflex_triggers: raw.reflex_triggers || [],
+          affected_tools: raw.affected_tools || [],
+          confidence_score: raw.confidence_score,
+          reflex_override: raw.reflex_override,
+          omega_components: raw.omega_components,
+          breaking_changes: raw.breaking_changes,
+          stats: raw.stats,
+          mitigation_available: raw.mitigation_available
+        };
+      }
+      // ─── 2. diff ───────────────────────────────────────────────────────────
+      /**
+       * Full analysis of two OpenAPI specs.
+       */
+      async diff(req) {
+        return this.request("POST", "/api/v1/diff", req);
+      }
+      // ─── 3. explainDecision ────────────────────────────────────────────────
+      /**
+       * Returns a human-readable explanation of why a decision was made.
+       *
+       * Computed client-side from the omega components and reflex triggers.
+       */
+      async explainDecision(req) {
+        const components = [];
+        if (req.omega_components) {
+          for (const [name, value] of Object.entries(req.omega_components)) {
+            if (typeof value === "number") {
+              components.push({
+                name,
+                value,
+                description: describeComponent(name, value)
+              });
+            }
+          }
+        }
+        const triggers = req.reflex_triggers || [];
+        let summary = `Decision: ${req.decision} (\u03A9_API = ${req.omega_api}).`;
+        if (triggers.length > 0) {
+          summary += ` ${triggers.length} reflex rule(s) triggered.`;
+        }
+        if (req.decision === "BLOCK") {
+          summary += " This change is blocked due to high risk.";
+        } else if (req.decision === "REQUIRE_APPROVAL") {
+          summary += " This change requires manual approval before merging.";
+        } else if (req.decision === "WARN") {
+          summary += " This change has warnings but can proceed.";
+        } else {
+          summary += " This change is safe to proceed.";
+        }
+        return { summary, components };
+      }
+      // ─── 4. howToUnblock ───────────────────────────────────────────────────
+      /**
+       * Returns actionable steps to resolve a BLOCK decision.
+       *
+       * Computed client-side from breaking changes and detected patterns.
+       */
+      async howToUnblock(req) {
+        const actions = [];
+        let step = 1;
+        if (req.decision !== "BLOCK") {
+          actions.push({
+            step: step++,
+            description: `Current decision is "${req.decision}" \u2014 no unblock needed.`
+          });
+          return { actions };
+        }
+        const bcs = req.breaking_changes || [];
+        if (bcs.length > 0) {
+          actions.push({
+            step: step++,
+            description: `Fix ${bcs.length} breaking change(s) in your spec.`,
+            code_example: bcs.slice(0, 3).map((bc) => `# ${bc.type} at ${bc.path}: ${bc.description}`).join("\n")
+          });
+        }
+        const triggers = req.reflex_triggers || [];
+        for (const trigger of triggers) {
+          actions.push({
+            step: step++,
+            description: `Resolve reflex rule: ${trigger.rule}`
+          });
+        }
+        actions.push({
+          step: step++,
+          description: "Request a manual override via POST /api/v1/ledger/:id/override if this is an emergency."
+        });
+        return { actions };
+      }
+      // ─── 5. scoreMcp ──────────────────────────────────────────────────────
+      /**
+       * Score an MCP manifest for agent safety.
+       */
+      async scoreMcp(req) {
+        return this.request("POST", "/api/v1/agent-readiness-score", {
+          spec: req.manifest,
+          spec_type: "mcp"
+        });
+      }
+      // ─── 6. getLedger ─────────────────────────────────────────────────────
+      /**
+       * Query compliance ledger entries.
+       */
+      async getLedger(req = {}) {
+        const params = new URLSearchParams();
+        if (req.repo)
+          params.set("repo", req.repo);
+        if (req.decision)
+          params.set("decision", req.decision);
+        if (req.from)
+          params.set("from", req.from);
+        if (req.to)
+          params.set("to", req.to);
+        if (req.limit)
+          params.set("limit", String(req.limit));
+        const qs = params.toString();
+        const path = `/api/v1/ledger${qs ? `?${qs}` : ""}`;
+        return this.request("GET", path);
+      }
+      // ─── 7. simulatePolicy ───────────────────────────────────────────────
+      /**
+       * Test a YAML policy against two OpenAPI specs.
+       */
+      async simulatePolicy(req) {
+        return this.request("POST", "/api/v1/policy-simulator", req);
+      }
+      // ─── 8. preflightChangeSet ─────────────────────────────────────────────
+      /**
+       * Preflight a multi-artifact change set (OpenAPI / GraphQL / gRPC / AsyncAPI / MCP manifest)
+       * in one call. Returns one aggregated ALLOW/WARN/REQUIRE_APPROVAL/BLOCK decision (strictest-wins)
+       * with per-artifact findings, a bundle fingerprint, and a decision-result.v1.1 envelope +
+       * chain receipt. POST /api/v1/preflight.
+       */
+      async preflightChangeSet(req) {
+        return this.request("POST", "/api/v1/preflight", req);
+      }
+      // ─── 9. verifyReceipt ──────────────────────────────────────────────────
+      /**
+       * Verify a CodeRifts chain receipt's signature and integrity. No API key is required — this is a
+       * public endpoint (the Authorization header is sent for consistency but ignored server-side).
+       * POST /api/v1/verify-receipt.
+       */
+      async verifyReceipt(token) {
+        return this.request("POST", "/api/v1/verify-receipt", { token });
+      }
+      // ─── 10. getDecisionDetails ────────────────────────────────────────────
+      /**
+       * Look up a stored decision by decision_id or fingerprint; returns the stored
+       * decision-result.v1.1 envelope + meta. POST /api/v1/decisions/lookup.
+       */
+      async getDecisionDetails(req) {
+        return this.request("POST", "/api/v1/decisions/lookup", req);
+      }
+    };
+    exports2.CodeRifts = CodeRifts;
+    function describeComponent(name, value) {
+      const descriptions = {
+        S_contract: "Contract severity score \u2014 measures how severe the breaking changes are",
+        P_break: "Break probability \u2014 likelihood that downstream consumers will break",
+        S_blast_eff: "Blast radius \u2014 how many consumers are affected",
+        S_agent: "Agent safety score \u2014 risk to AI agent tool invocations",
+        S_runtime: "Runtime impact \u2014 risk of runtime failures",
+        ECI: "Ecosystem coupling index \u2014 how tightly coupled the API is",
+        M_eff: "Migration effort \u2014 estimated effort to migrate consumers",
+        D_contract: "Contract distance \u2014 semantic distance between old and new contracts",
+        confidence_score: "Confidence in the analysis result"
+      };
+      return descriptions[name] || `${name} = ${value}`;
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/sdk/dist/cjs/decision.js
+var require_decision = __commonJS({
+  "../../node_modules/@coderifts/sdk/dist/cjs/decision.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.readDecision = readDecision;
+    var EXECUTION_ACTION = {
+      ALLOW: "CONTINUE",
+      WARN: "CONTINUE_WITH_MONITORING",
+      REQUIRE_APPROVAL: "REQUEST_APPROVAL",
+      BLOCK: "STOP"
+    };
+    function isExecutionAction(v) {
+      return v === "CONTINUE" || v === "CONTINUE_WITH_MONITORING" || v === "REQUEST_APPROVAL" || v === "STOP";
+    }
+    function readDecision(response) {
+      if (!response || typeof response !== "object") {
+        return { executionAction: "STOP", decision: null, reason: "UNREADABLE_DECISION" };
+      }
+      const r = response;
+      const env = r.decision_result;
+      if (env && typeof env === "object" && isExecutionAction(env.execution_action)) {
+        const receipt = env.receipt;
+        return {
+          executionAction: env.execution_action,
+          decision: typeof env.decision === "string" ? env.decision : null,
+          envelope: env,
+          receipt: receipt && typeof receipt === "object" ? receipt : void 0
+        };
+      }
+      if (isExecutionAction(r.execution_action)) {
+        return {
+          executionAction: r.execution_action,
+          decision: typeof r.decision === "string" ? r.decision : null
+        };
+      }
+      if (typeof r.decision === "string" && Object.prototype.hasOwnProperty.call(EXECUTION_ACTION, r.decision)) {
+        return { executionAction: EXECUTION_ACTION[r.decision], decision: r.decision };
+      }
+      return {
+        executionAction: "STOP",
+        decision: typeof r.decision === "string" ? r.decision : null,
+        reason: "UNREADABLE_DECISION"
+      };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/sdk/dist/cjs/index.js
+var require_cjs3 = __commonJS({
+  "../../node_modules/@coderifts/sdk/dist/cjs/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.readDecision = exports2.AuthError = exports2.RateLimitError = exports2.TimeoutError = exports2.ApiError = exports2.CodeRiftsError = exports2.CodeRifts = void 0;
+    var client_js_1 = require_client();
+    Object.defineProperty(exports2, "CodeRifts", { enumerable: true, get: function() {
+      return client_js_1.CodeRifts;
+    } });
+    var errors_js_1 = require_errors5();
+    Object.defineProperty(exports2, "CodeRiftsError", { enumerable: true, get: function() {
+      return errors_js_1.CodeRiftsError;
+    } });
+    Object.defineProperty(exports2, "ApiError", { enumerable: true, get: function() {
+      return errors_js_1.ApiError;
+    } });
+    Object.defineProperty(exports2, "TimeoutError", { enumerable: true, get: function() {
+      return errors_js_1.TimeoutError;
+    } });
+    Object.defineProperty(exports2, "RateLimitError", { enumerable: true, get: function() {
+      return errors_js_1.RateLimitError;
+    } });
+    Object.defineProperty(exports2, "AuthError", { enumerable: true, get: function() {
+      return errors_js_1.AuthError;
+    } });
+    var decision_js_1 = require_decision();
+    Object.defineProperty(exports2, "readDecision", { enumerable: true, get: function() {
+      return decision_js_1.readDecision;
+    } });
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/detector.js
+var require_detector = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/detector.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.builtinDetector = exports2.DETECTOR_VERSION = void 0;
+    var node_zlib_1 = require("node:zlib");
+    exports2.DETECTOR_VERSION = "builtin/1.1.0";
+    var CONTRACT_PATH_RE = [
+      /openapi/i,
+      /swagger/i,
+      /asyncapi/i,
+      /\.graphql$/i,
+      /\.gql$/i,
+      /\.proto$/i,
+      /\.pb($|\.)/i,
+      /(^|\/)[\w.-]*mcp[\w.-]*\.json$/i,
+      /tools-catalog\.json$/i,
+      /schema\.prisma$/i,
+      /(^|\/)migrations?\//i,
+      /(^|\/)alembic\//i,
+      /(^|\/)buf\.ya?ml$/i,
+      /\.spectral\.ya?ml$/i,
+      /(^|\/)\.github\/workflows\//i,
+      /(^|\/)\.husky\//i,
+      /api[-_]?contract/i,
+      /service-definition/i,
+      /(^|\/)contracts?\//i,
+      /schemas?\/components?\//i,
+      /\bcontract\.json$/i,
+      /(^|\/)spec\.(ya?ml|json)$/i,
+      /api[-_/]spec\.(ya?ml|json)$/i,
+      /-api\.(ya?ml|yml)$/i,
+      /current-api/i,
+      /(^|\/)(src\/)?generated\//i,
+      /(^|\/)gen\//i,
+      /\.pb\.go$/i,
+      /openapi\.d\.ts$/i
+    ];
+    var NON_SSOT_PATH_RE = [
+      /(^|\/)tests?\//i,
+      /(^|\/)__tests__\//i,
+      /(^|\/)__mocks__\//i,
+      /\/fixtures?\//i,
+      /(^|\/)mocks?\//i,
+      /\.test\.[jt]sx?$/i,
+      /\.spec\.[jt]sx?$/i,
+      /(^|\/)src\/internal\//i,
+      /(^|\/)node_modules\//i
+    ];
+    var PROSE_PATH_RE = [/(^|\/)README(\.\w+)?$/i, /(^|\/)CHANGELOG(\.\w+)?$/i, /(^|\/)LICENSE(\.\w+)?$/i, /\.md$/i];
+    var CODE_CONTRACT_PATH_RE = [/(^|\/)src\/routes?\//i, /(^|\/)routes?\//i, /(^|\/)app\/api\//i, /(^|\/)src\/dto\//i, /dto/i, /routers?\//i, /\.prisma$/i, /\.tf$/i, /server\/routers?\//i];
+    var GATE_PATH_RE = [/(^|\/)\.github\/workflows\//i, /(^|\/)\.husky\//i, /\.spectral\.ya?ml$/i, /(^|\/)buf\.ya?ml$/i];
+    var LOCKFILE_RE = /(package-lock\.json|pnpm-lock\.ya?ml|yarn\.lock|composer\.lock|Cargo\.lock)$/i;
+    var CONTRACT_CONTENT_RE = [
+      /\bopenapi\s*[:=]\s*["']?3/i,
+      /["']openapi["']\s*:/i,
+      /\bswagger\s*[:=]/i,
+      /["']swagger["']\s*:/i,
+      /\basyncapi\s*[:=]/i,
+      /["']asyncapi["']\s*:/i,
+      /(^|\n)\s*paths\s*:/i,
+      /["']paths["']\s*:/i,
+      /syntax\s*=\s*["']proto3/i,
+      /(^|\n)\s*message\s+\w+\s*\{/i,
+      /\btype\s+(Query|Mutation|Subscription)\b/i,
+      /["']tools["']\s*:\s*\[/i,
+      /["']inputSchema["']\s*:/i,
+      /\/v\d+\/[\w{}.-]*\s*:/,
+      // versioned route-path key
+      /\bchannels\s*:/i
+    ];
+    var CONTRACT_STRUCTURE_RE = [
+      /(get|post|put|delete|patch)\s*:\s*\{?/i,
+      /message\s+\w+\s*\{[^}]*=\s*\d+/i,
+      /\/v\d+\/[\w{}.-]*\s*:/,
+      /"name"\s*:\s*"[^"]+"[\s,}]*"?inputSchema/i
+    ];
+    var REAL_CHANGE_RE = [
+      /required\s*:\s*\[/i,
+      /["']required["']\s*:\s*\[/i,
+      /\btype\s*:\s*\w+/i,
+      /nullable\s*:/i,
+      /:\s*\w+!/,
+      /additionalProperties\s*:\s*(true|false)/i,
+      /["']additionalProperties["']/i,
+      /\bDROP\s+COLUMN\b/i,
+      /\bALTER\s+COLUMN\b/i,
+      /alter_column\s*\(/i,
+      /new_column_name/i,
+      /\bRENAME\b/i,
+      /DROP\s+TABLE/i,
+      /@IsString|@IsOptional|response_model|z\.string|@unique/i,
+      /app\.(get|post|put|delete|patch)\s*\(/i,
+      /@router\.(get|post|put|delete|patch)/i,
+      /\/v\d+\//,
+      /continue-on-error|if:\s*false|:\s*off\b|'off'|"off"/i,
+      /\bignore\s*:/i,
+      /(^|\n)\s*breaking\s*:/i
+    ];
+    var INERT_KEY_RE = [
+      /^description\s*:/i,
+      /^["']description["']\s*:/i,
+      /^summary\s*:/i,
+      /^title\s*:/i,
+      /^contact\s*:/i,
+      /^name\s*:/i,
+      /^examples?\s*:/i,
+      /^["']examples?["']\s*:/i,
+      /^x-[\w-]+\s*:/i,
+      /^["']x-[\w-]+["']\s*:/i
+    ];
+    var READ_ONLY_TOOLS = /* @__PURE__ */ new Set(["read", "grep", "glob", "ls", "cat", "view", "search", "list", "get"]);
+    var FORMATTER_RE = /\b(prettier|eslint\s+--fix|gofmt|rustfmt|black|clang-format|dprint)\b/i;
+    var GATE_KEYWORD_RE = /coderifts|agent-guard|contract-check|contract\b|preflight|spectral|\bbuf\b/i;
+    function anyMatch(res, s) {
+      return res.some((r) => r.test(s));
+    }
+    function argString(args) {
+      if (args == null)
+        return "";
+      if (typeof args === "string")
+        return args;
+      try {
+        return JSON.stringify(args);
+      } catch {
+        return "";
+      }
+    }
+    function changeText(call) {
+      const parts = [];
+      if (call.diff)
+        parts.push(call.diff);
+      const a = call.arguments;
+      if (a && typeof a === "object") {
+        for (const k of ["new_string", "old_string", "contents", "content", "patch", "command"]) {
+          const v = a[k];
+          if (typeof v === "string")
+            parts.push(v);
+        }
+        const edits = a.edits;
+        if (Array.isArray(edits))
+          for (const e of edits)
+            parts.push(argString(e));
+      }
+      return parts.join("\n");
+    }
+    function commandText(call) {
+      const a = call.arguments;
+      const c = a && typeof a === "object" ? a.command : void 0;
+      return typeof c === "string" ? c : "";
+    }
+    function allPaths(call) {
+      const out = [...call.filesTouched || []];
+      const a = call.arguments;
+      if (a && typeof a === "object" && typeof a.path === "string")
+        out.push(a.path);
+      return out;
+    }
+    function isContractPath(p) {
+      if (anyMatch(NON_SSOT_PATH_RE, p))
+        return false;
+      if (anyMatch(PROSE_PATH_RE, p))
+        return false;
+      return anyMatch(CONTRACT_PATH_RE, p);
+    }
+    function changedLines(call) {
+      if (call.diff) {
+        return call.diff.split("\n").filter((l) => l.startsWith("+") || l.startsWith("-")).map((l) => l.slice(1));
+      }
+      const out = [];
+      const a = call.arguments;
+      const pushSetDiff = (oldS, newS) => {
+        const oldL = typeof oldS === "string" ? oldS.split("\n") : [];
+        const newL = typeof newS === "string" ? newS.split("\n") : [];
+        const oldSet = new Set(oldL.map((l) => l.trim()));
+        const newSet = new Set(newL.map((l) => l.trim()));
+        for (const l of newL)
+          if (!oldSet.has(l.trim()))
+            out.push(l);
+        for (const l of oldL)
+          if (!newSet.has(l.trim()))
+            out.push(l);
+      };
+      if (a && typeof a === "object") {
+        pushSetDiff(a.old_string, a.new_string);
+        const contents = a.contents ?? a.content;
+        if (typeof contents === "string")
+          for (const l of contents.split("\n"))
+            out.push(l);
+        const patch = a.patch;
+        if (typeof patch === "string") {
+          for (const l of patch.split("\n"))
+            if (l.startsWith("+") || l.startsWith("-"))
+              out.push(l.slice(1));
+        }
+        const edits = a.edits;
+        if (Array.isArray(edits)) {
+          for (const e of edits)
+            if (e && typeof e === "object")
+              pushSetDiff(e.old_string, e.new_string);
+        }
+      }
+      return out;
+    }
+    function migrationDestructive(text) {
+      return /\bDROP\s+COLUMN\b|\bALTER\s+COLUMN\b|new_column_name|alter_column|\bRENAME\b|DROP\s+TABLE|DROP\s+CONSTRAINT/i.test(text);
+    }
+    function migrationIndexOnly(text) {
+      return /CREATE\s+INDEX/i.test(text) && !migrationDestructive(text) && !/ADD\s+COLUMN|DROP\b/i.test(text);
+    }
+    function gateDisabled(call) {
+      const paths = allPaths(call);
+      if (!paths.some((p) => anyMatch(GATE_PATH_RE, p)))
+        return false;
+      const text = changeText(call);
+      if (!GATE_KEYWORD_RE.test(text))
+        return false;
+      const lines = changedLines(call);
+      const commentedOut = lines.some((l) => /^\s*(#|\/\/)/.test(l) && GATE_KEYWORD_RE.test(l));
+      const weakened = anyMatch(REAL_CHANGE_RE, text) || /continue-on-error|if:\s*false|:\s*off\b|ignore\s*:/i.test(text);
+      return commentedOut || weakened;
+    }
+    function lockfileContractChange(call) {
+      const paths = allPaths(call);
+      if (!paths.some((p) => LOCKFILE_RE.test(p)))
+        return false;
+      const text = changeText(call);
+      const contractPkg = /@[\w.-]+\/(openapi|graphql|proto|asyncapi|schema)\b|(openapi|graphql|proto|asyncapi|schema)@\d/i.test(text);
+      if (!contractPkg)
+        return false;
+      return /"resolved"\s*:/i.test(text) || /@\d+\.\d+\.\d+/.test(text) || /@\d+['":]/.test(text);
+    }
+    function isInertOnly(call) {
+      const text = changeText(call);
+      const paths = allPaths(call);
+      if (paths.some((p) => LOCKFILE_RE.test(p)) && !lockfileContractChange(call)) {
+        if (/"integrity"\s*:/i.test(text) && !/"resolved"\s*:/i.test(text))
+          return true;
+      }
+      if (paths.some((p) => /migrations?\/|alembic\//i.test(p)) && migrationIndexOnly(text))
+        return true;
+      if (paths.some((p) => anyMatch(GATE_PATH_RE, p))) {
+        if (!GATE_KEYWORD_RE.test(text) && !anyMatch(REAL_CHANGE_RE, text))
+          return true;
+        return false;
+      }
+      const cmd = commandText(call);
+      if (cmd && FORMATTER_RE.test(cmd))
+        return true;
+      if (/\b(examples?|value)\s*:/i.test(text) && !anyMatch(REAL_CHANGE_RE, text))
+        return true;
+      const lines = changedLines(call);
+      if (lines.length === 0)
+        return false;
+      let sawReal = false;
+      let sawInert = false;
+      for (const raw of lines) {
+        const t = raw.trim();
+        if (t === "") {
+          sawInert = true;
+          continue;
+        }
+        if (/^#|^\/\/|^\/\*|\*\/|^\*/.test(t)) {
+          sawInert = true;
+          continue;
+        }
+        if (/^```/.test(t)) {
+          sawInert = true;
+          continue;
+        }
+        if (/^["'].*["']$/.test(t) && !t.includes(":")) {
+          sawInert = true;
+          continue;
+        }
+        if (/generated|timestamp/i.test(t)) {
+          sawInert = true;
+          continue;
+        }
+        if (anyMatch(INERT_KEY_RE, t)) {
+          sawInert = true;
+          continue;
+        }
+        if (anyMatch(REAL_CHANGE_RE, t) || anyMatch(CONTRACT_STRUCTURE_RE, t) || anyMatch(CONTRACT_CONTENT_RE, t)) {
+          sawReal = true;
+          continue;
+        }
+        if (/^[\w"']+\??\s*:\s*\S/.test(t)) {
+          sawReal = true;
+          continue;
+        }
+      }
+      return sawInert && !sawReal;
+    }
+    function realChangePresent(call) {
+      const text = changeText(call);
+      if (migrationDestructive(text))
+        return true;
+      if (gateDisabled(call))
+        return true;
+      if (lockfileContractChange(call))
+        return true;
+      for (const raw of changedLines(call)) {
+        const t = raw.trim();
+        if (anyMatch(INERT_KEY_RE, t))
+          continue;
+        if (anyMatch(REAL_CHANGE_RE, t))
+          return true;
+        if (/^[\w"']+\??\s*:\s*\S/.test(t) && !/^(paths|components|info|servers|channels|tools|get|post|put|delete|patch)\s*:/i.test(t))
+          return true;
+      }
+      return false;
+    }
+    function intentMentionsContract(intent) {
+      if (!intent)
+        return false;
+      return /openapi|swagger|graphql|protobuf|\bproto\b|asyncapi|mcp\s*manifest|mcp\.json|json\s*schema|\bschema\b|required\s+field|\bendpoint\b|wire\s*format|api\s*spec|contract\s*(file|change|surface)/i.test(intent);
+    }
+    function commandMutatesContract(call) {
+      const cmd = commandText(call);
+      if (!cmd)
+        return false;
+      if (FORMATTER_RE.test(cmd))
+        return false;
+      const touchesContract = allPaths(call).some(isContractPath) || /(>|>>|-o\s|mv\s|ln\s+-sf?\s|git\s+mv\s|cp\s)[^\n|]*(openapi|swagger|asyncapi|\.graphql|\.gql|\.proto|\.pb\b|mcp[.-]?\w*\.json|schema\.prisma|spec\.(ya?ml|json))/i.test(cmd) || anyMatch(CONTRACT_CONTENT_RE, cmd);
+      const mutates = /(>|>>|\bmv\b|\bcp\b|\bln\s|git\s+mv|curl|wget|-o\b|base64\s+-d|xxd|\bjq\b|\bsed\b|\btee\b|echo|printf|\bcat\b)/i.test(cmd);
+      return touchesContract && mutates;
+    }
+    var DEEP_MAX_DEPTH = 8;
+    var DEEP_MAX_BYTES = 262144;
+    var DEEP_DECODE_MAX_BYTES = 65536;
+    var DEEP_DECODE_LEVELS = 3;
+    var OPAQUE_MIN_LEN = 40;
+    function looksLikePath(v) {
+      return v.length > 0 && v.length <= 256 && !/[\n\r{}<>]/.test(v) && /(^|\/)[\w.@-]+\.[A-Za-z0-9]+$/.test(v.trim());
+    }
+    function decodeCandidates(v) {
+      const out = [];
+      const push = (s) => {
+        if (s && s.length > 0 && s.length <= DEEP_DECODE_MAX_BYTES)
+          out.push(s);
+      };
+      const compact = v.replace(/\s+/g, "");
+      if (compact.length >= 16 && compact.length % 4 === 0 && /^[A-Za-z0-9+/]+={0,2}$/.test(compact)) {
+        try {
+          push(Buffer.from(compact, "base64").toString("utf8"));
+        } catch {
+        }
+        try {
+          const b = Buffer.from(compact, "base64");
+          push((0, node_zlib_1.gunzipSync)(b).toString("utf8"));
+        } catch {
+        }
+      }
+      if (compact.length >= 16 && compact.length % 2 === 0 && /^[0-9a-fA-F]+$/.test(compact)) {
+        try {
+          push(Buffer.from(compact, "hex").toString("utf8"));
+        } catch {
+        }
+      }
+      if (/%[0-9a-fA-F]{2}/.test(v)) {
+        try {
+          push(decodeURIComponent(v));
+        } catch {
+        }
+      }
+      if (/\\["\\/]|^\s*"/.test(v)) {
+        try {
+          const p = JSON.parse(v);
+          if (typeof p === "string")
+            push(p);
+        } catch {
+        }
+      }
+      return out;
+    }
+    function looksEncoded(v) {
+      const c = v.replace(/\s+/g, "");
+      if (c.length < OPAQUE_MIN_LEN)
+        return false;
+      return /^[A-Za-z0-9+/]+={0,2}$/.test(c) && c.length % 4 === 0 || /^[0-9a-fA-F]+$/.test(c) && c.length % 2 === 0;
+    }
+    function deepArgScan(call) {
+      const acc = { contractContent: false, pathContractSsot: false, pathNonSsot: false, pathLikeCount: 0, proseCount: 0, opaque: false, capHit: false };
+      let budget = DEEP_MAX_BYTES;
+      const scanString = (s) => {
+        if (looksLikePath(s)) {
+          acc.pathLikeCount++;
+          if (anyMatch(NON_SSOT_PATH_RE, s))
+            acc.pathNonSsot = true;
+          else if (anyMatch(PROSE_PATH_RE, s))
+            acc.proseCount++;
+          else if (isContractPath(s))
+            acc.pathContractSsot = true;
+          return;
+        }
+        if (anyMatch(CONTRACT_CONTENT_RE, s) || anyMatch(CONTRACT_STRUCTURE_RE, s)) {
+          acc.contractContent = true;
+          return;
+        }
+        let level = [s];
+        for (let d = 0; d < DEEP_DECODE_LEVELS && !acc.contractContent; d++) {
+          const next = [];
+          for (const val of level) {
+            for (const dec of decodeCandidates(val)) {
+              if (anyMatch(CONTRACT_CONTENT_RE, dec) || anyMatch(CONTRACT_STRUCTURE_RE, dec)) {
+                acc.contractContent = true;
+                break;
+              }
+              next.push(dec);
+            }
+            if (acc.contractContent)
+              break;
+          }
+          level = next;
+        }
+        if (!acc.contractContent && looksEncoded(s) && level.every((x) => !isReadableText(x)))
+          acc.opaque = true;
+      };
+      const walk = (node, depth) => {
+        if (acc.capHit || budget <= 0)
+          return;
+        if (depth > DEEP_MAX_DEPTH) {
+          acc.capHit = true;
+          return;
+        }
+        if (typeof node === "string") {
+          budget -= node.length;
+          if (budget <= 0) {
+            acc.capHit = true;
+            return;
+          }
+          scanString(node);
+        } else if (Array.isArray(node)) {
+          for (const el of node) {
+            if (acc.capHit)
+              break;
+            walk(el, depth + 1);
+          }
+        } else if (node && typeof node === "object") {
+          for (const val of Object.values(node)) {
+            if (acc.capHit)
+              break;
+            walk(val, depth + 1);
+          }
+        }
+      };
+      try {
+        walk(call.arguments, 0);
+      } catch {
+        acc.capHit = true;
+      }
+      return acc;
+    }
+    function isReadableText(s) {
+      if (!s)
+        return false;
+      let printable = 0;
+      const n = Math.min(s.length, 512);
+      for (let i = 0; i < n; i++) {
+        const c = s.charCodeAt(i);
+        if (c === 9 || c === 10 || c === 13 || c >= 32 && c < 127)
+          printable++;
+      }
+      return printable / n > 0.85;
+    }
+    exports2.builtinDetector = {
+      version: exports2.DETECTOR_VERSION,
+      detect(call) {
+        const signals = [];
+        const artifacts = Array.isArray(call.artifacts) ? call.artifacts : [];
+        if (artifacts.length > 0)
+          return { trigger: true, artifacts, signals: ["explicit_artifacts"], confident: true };
+        if (READ_ONLY_TOOLS.has(String(call.toolName).toLowerCase()) && !commandMutatesContract(call)) {
+          return { trigger: false, artifacts: [], signals: ["non_mutating_tool"], confident: true };
+        }
+        const paths = allPaths(call);
+        const contractPath = paths.some(isContractPath);
+        const codeContractPath = paths.some((p) => anyMatch(CODE_CONTRACT_PATH_RE, p) && !anyMatch(NON_SSOT_PATH_RE, p));
+        const change = changeText(call);
+        const inProse = paths.length > 0 && paths.every((p) => anyMatch(PROSE_PATH_RE, p));
+        const contentMarker = anyMatch(CONTRACT_CONTENT_RE, change) && !paths.some((p) => anyMatch(NON_SSOT_PATH_RE, p)) && !inProse;
+        const shellMutation = commandMutatesContract(call);
+        const gate = gateDisabled(call);
+        const lockContract = lockfileContractChange(call);
+        const contractSurface = contractPath || contentMarker || shellMutation || codeContractPath || gate || lockContract;
+        if (contractSurface) {
+          if (shellMutation) {
+            signals.push("shell_mutates_contract");
+            return { trigger: true, artifacts, signals, confident: true };
+          }
+          if (gate) {
+            signals.push("contract_gate_disabled");
+            return { trigger: true, artifacts, signals, confident: true };
+          }
+          if (lockContract) {
+            signals.push("lockfile_contract_redirect");
+            return { trigger: true, artifacts, signals, confident: true };
+          }
+          if (isInertOnly(call)) {
+            signals.push("inert_change_only");
+            return { trigger: false, artifacts: [], signals, confident: true };
+          }
+          if (realChangePresent(call) || contentMarker || anyMatch(CONTRACT_STRUCTURE_RE, change)) {
+            signals.push("contract_change");
+            return { trigger: true, artifacts, signals, confident: true };
+          }
+          signals.push("ambiguous_contract_surface");
+          return { trigger: true, artifacts, signals, confident: false };
+        }
+        const deep = deepArgScan(call);
+        if (deep.contractContent || deep.pathContractSsot) {
+          const deepInProse = deep.pathLikeCount > 0 && deep.proseCount === deep.pathLikeCount && !deep.pathContractSsot;
+          if (!deep.pathNonSsot && !deepInProse && !isInertOnly(call)) {
+            signals.push(deep.contractContent ? "arguments_deep_contract" : "arguments_deep_path");
+            return { trigger: true, artifacts, signals, confident: false };
+          }
+        }
+        if (deep.opaque || deep.capHit) {
+          signals.push(deep.capHit ? "arguments_scan_capped" : "arguments_opaque");
+          return { trigger: true, artifacts, signals, confident: false };
+        }
+        if (intentMentionsContract(call.intent)) {
+          signals.push("intent_contract_reference");
+          return { trigger: true, artifacts, signals, confident: false };
+        }
+        signals.push("no_contract_signal");
+        return { trigger: false, artifacts: [], signals, confident: true };
+      }
+    };
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/receipt-binding.js
+var require_receipt_binding = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/receipt-binding.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.canonicalJson = canonicalJson;
+    exports2.computeBodyHash = computeBodyHash;
+    exports2.bindReceiptToEnvelope = bindReceiptToEnvelope;
+    var node_crypto_1 = require("node:crypto");
+    function canonicalJson(value) {
+      return encode(value);
+    }
+    function encode(value) {
+      if (value === null)
+        return "null";
+      const t = typeof value;
+      if (t === "boolean" || t === "string")
+        return JSON.stringify(value);
+      if (t === "number") {
+        if (!Number.isFinite(value))
+          throw new TypeError("canonicalJson: non-finite number is not representable");
+        return JSON.stringify(value);
+      }
+      if (t === "undefined")
+        throw new TypeError("canonicalJson: undefined is not representable (omit the key instead)");
+      if (Array.isArray(value))
+        return `[${value.map(encode).join(",")}]`;
+      if (t === "object") {
+        const obj = value;
+        const keys = Object.keys(obj).sort();
+        return `{${keys.map((k) => `${JSON.stringify(k)}:${encode(obj[k])}`).join(",")}}`;
+      }
+      throw new TypeError(`canonicalJson: unsupported type ${t}`);
+    }
+    function sha256hex(s) {
+      return (0, node_crypto_1.createHash)("sha256").update(s).digest("hex");
+    }
+    function computeBodyHash(envelope) {
+      const rest = { ...envelope };
+      delete rest.receipt;
+      delete rest.decision_body_hash;
+      return `sha256:${sha256hex(canonicalJson(rest))}`;
+    }
+    function bindReceiptToEnvelope(envelope, vr, ctx = {}) {
+      if (!envelope)
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: "no envelope" };
+      if (!vr || vr.valid !== true)
+        return { ok: false, cause: "RECEIPT_UNVERIFIED", detail: `valid=${vr ? vr.valid : "none"}` };
+      if (vr.status !== "VERIFIED_CURRENT") {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: `status ${vr.status ?? "unknown"} != VERIFIED_CURRENT` };
+      }
+      const payload = vr.payload || {};
+      const localBh = computeBodyHash(envelope);
+      if (typeof payload.bh !== "string" || payload.bh !== localBh) {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: "decision_body_hash mismatch (receipt was signed over a different envelope)" };
+      }
+      if (typeof payload.fp !== "string" || payload.fp !== envelope.fingerprint) {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: "verdict_fingerprint mismatch" };
+      }
+      const requestedOp = ctx.operation ?? "tool_call";
+      if (envelope.operation != null && requestedOp != null && envelope.operation !== requestedOp) {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: `operation ${String(envelope.operation)} != ${String(requestedOp)}` };
+      }
+      if (ctx.environment != null && envelope.environment != null && envelope.environment !== ctx.environment) {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: `environment ${String(envelope.environment)} != ${String(ctx.environment)}` };
+      }
+      if (ctx.audience != null && envelope.audience != null && envelope.audience !== ctx.audience) {
+        return { ok: false, cause: "RECEIPT_ENVELOPE_MISMATCH", detail: `audience ${String(envelope.audience)} != ${String(ctx.audience)}` };
+      }
+      return { ok: true };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/enforcement-gate.js
+var require_enforcement_gate = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/enforcement-gate.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.computeArtifactDigest = computeArtifactDigest;
+    exports2.computeBundleFingerprint = computeBundleFingerprint;
+    exports2.evaluateEnvelope = evaluateEnvelope;
+    var node_crypto_1 = require("node:crypto");
+    var DECISION_RANK = { ALLOW: 0, WARN: 1, REQUIRE_APPROVAL: 2, BLOCK: 3 };
+    var ACTION_TO_DECISION = {
+      CONTINUE: "ALLOW",
+      CONTINUE_WITH_MONITORING: "WARN",
+      REQUEST_APPROVAL: "REQUIRE_APPROVAL",
+      STOP: "BLOCK"
+    };
+    var DECISION_TO_ACTION = {
+      ALLOW: "CONTINUE",
+      WARN: "CONTINUE_WITH_MONITORING",
+      REQUIRE_APPROVAL: "REQUEST_APPROVAL",
+      BLOCK: "STOP"
+    };
+    function isDecision(v) {
+      return v === "ALLOW" || v === "WARN" || v === "REQUIRE_APPROVAL" || v === "BLOCK";
+    }
+    function isAction(v) {
+      return v === "CONTINUE" || v === "CONTINUE_WITH_MONITORING" || v === "REQUEST_APPROVAL" || v === "STOP";
+    }
+    var NUL = "";
+    function sha256hex(s) {
+      return (0, node_crypto_1.createHash)("sha256").update(s).digest("hex");
+    }
+    function specStr(v) {
+      return v == null ? "" : typeof v === "string" ? v : JSON.stringify(v);
+    }
+    function computeArtifactDigest(artifacts) {
+      const preimage = artifacts.slice().sort((a, b) => `${a.type}${NUL}${a.id}` < `${b.type}${NUL}${b.id}` ? -1 : 1).map((a) => `${sha256hex(specStr(a.before))}${sha256hex(specStr(a.after))}`).join(NUL);
+      return `sha256:${sha256hex(preimage)}`;
+    }
+    function computeBundleFingerprint(artifacts) {
+      const parts = artifacts.slice().sort((a, b) => `${a.type}${NUL}${a.id}` < `${b.type}${NUL}${b.id}` ? -1 : 1).map((a) => [a.type, a.id, sha256hex(specStr(a.before)), sha256hex(specStr(a.after))].join(NUL));
+      return `sha256:${sha256hex(parts.join(NUL))}`;
+    }
+    function evaluateEnvelope(response, envelope, executionAction, sentArtifacts) {
+      const dec = envelope.decision;
+      if (!isDecision(dec)) {
+        return { verdict: "fail-closed", cause: "DECISION_INCONSISTENT", detail: `decision=${JSON.stringify(dec)} is missing/invalid` };
+      }
+      const signals = [dec, ACTION_TO_DECISION[executionAction]];
+      const top = response && typeof response === "object" ? response : {};
+      if (isDecision(top.decision))
+        signals.push(top.decision);
+      if (isAction(top.execution_action))
+        signals.push(ACTION_TO_DECISION[top.execution_action]);
+      const effective = signals.reduce((a, b) => DECISION_RANK[b] > DECISION_RANK[a] ? b : a);
+      if (DECISION_RANK[effective] >= DECISION_RANK.REQUIRE_APPROVAL) {
+        return { verdict: "block-strict", decision: effective };
+      }
+      if (DECISION_TO_ACTION[dec] !== executionAction) {
+        return { verdict: "fail-closed", cause: "DECISION_INCONSISTENT", detail: `decision=${dec} \u2260 execution_action=${executionAction}` };
+      }
+      if (envelope.safe_for_agent === false) {
+        return { verdict: "fail-closed", cause: "DECISION_INCONSISTENT", detail: "safe_for_agent=false on an allow-class decision" };
+      }
+      const degradedReasons = envelope.degraded_reasons;
+      if (envelope.analysis_complete === false || Array.isArray(degradedReasons) && degradedReasons.length > 0 || envelope.degraded === true || envelope.coverage_gap === true) {
+        return { verdict: "fail-closed", cause: "ANALYSIS_DEGRADED", detail: "analysis degraded / incomplete" };
+      }
+      if (Array.isArray(sentArtifacts) && sentArtifacts.length > 0 && typeof envelope.artifact_digest === "string" && envelope.artifact_digest !== computeArtifactDigest(sentArtifacts)) {
+        return { verdict: "fail-closed", cause: "ARTIFACT_MISMATCH", detail: "artifact_digest \u2260 locally-recomputed digest of sent artifacts" };
+      }
+      return { verdict: "allow", kind: effective === "ALLOW" ? "ALLOW" : "MONITOR" };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/guard.js
+var require_guard = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/guard.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.guardToolCall = guardToolCall;
+    var node_crypto_1 = require("node:crypto");
+    var sdk_1 = require_cjs3();
+    var detector_js_1 = require_detector();
+    var receipt_binding_js_1 = require_receipt_binding();
+    var enforcement_gate_js_1 = require_enforcement_gate();
+    var breakers = /* @__PURE__ */ new WeakMap();
+    var nowMs = () => Date.now();
+    var iso = () => (/* @__PURE__ */ new Date()).toISOString();
+    function emit(config, e) {
+      if (config.onEvent) {
+        try {
+          config.onEvent(e);
+        } catch {
+        }
+      }
+    }
+    function fingerprint(call) {
+      const canon = JSON.stringify({ toolName: call.toolName, arguments: call.arguments, artifacts: call.artifacts, filesTouched: call.filesTouched, diff: call.diff });
+      return "sha256:" + (0, node_crypto_1.createHash)("sha256").update(canon).digest("hex");
+    }
+    function breakerRecord(config) {
+      let s = breakers.get(config);
+      if (!s) {
+        s = { fails: [] };
+        breakers.set(config, s);
+      }
+      s.fails.push(nowMs());
+    }
+    function breakerTripped(config) {
+      const s = breakers.get(config);
+      if (!s)
+        return false;
+      const win = config.breakerWindowMs ?? 6e4;
+      const t = nowMs();
+      s.fails = s.fails.filter((x) => t - x < win);
+      return s.fails.length >= (config.maxUnavailablePerWindow ?? 3);
+    }
+    function classifyError(err, config) {
+      const e = err;
+      const name = e?.name;
+      const status = e?.status ?? e?.body?.status;
+      if (name === "TimeoutError" || name === "AbortError" || e?.code === "ABORT_ERR")
+        return { cause: "TIMEOUT", integrity: false };
+      if (status === 429 || name === "RateLimitError")
+        return { cause: "RATE_LIMITED", integrity: false };
+      if (status === 413)
+        return { cause: "PAYLOAD_TOO_LARGE", integrity: true };
+      if (status === 422)
+        return { cause: "REQUEST_REJECTED", integrity: true };
+      if (status === 400 || status === 401 || status === 409)
+        return { cause: "REQUEST_REJECTED", integrity: true };
+      if (typeof status === "number" && status >= 500)
+        return { cause: "SERVER_ERROR", integrity: false };
+      if (name === "TypeError" || /fetch failed|network|ENOTFOUND|ECONNREFUSED|EAI_AGAIN/i.test(String(e?.message)))
+        return { cause: "NETWORK", integrity: false };
+      if (name === "ApiError")
+        return { cause: "SERVER_ERROR", integrity: false };
+      return { cause: "INVALID_RESPONSE", integrity: true };
+    }
+    function withTimeout(p, ms) {
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(Object.assign(new Error(`preflight timed out after ${ms}ms`), { name: "TimeoutError" })), Math.max(1, ms));
+        p.then((v) => {
+          clearTimeout(timer);
+          resolve(v);
+        }, (e) => {
+          clearTimeout(timer);
+          reject(e);
+        });
+      });
+    }
+    async function preflightWithRetry(config, request) {
+      const retries = config.retries ?? 1;
+      const timeoutMs = config.timeoutMs ?? 2e3;
+      const budget = config.totalBudgetMs ?? 4500;
+      const start = nowMs();
+      let last = { cause: "TIMEOUT", integrity: false };
+      for (let attempt = 0; attempt <= retries; attempt++) {
+        const remaining = budget - (nowMs() - start);
+        if (remaining <= 0)
+          return { ok: false, cause: "TIMEOUT", integrity: false };
+        try {
+          const response = await withTimeout(config.client.preflightChangeSet(request), Math.min(timeoutMs, remaining));
+          return { ok: true, response };
+        } catch (err) {
+          last = classifyError(err, config);
+          if (last.integrity)
+            return { ok: false, ...last };
+        }
+      }
+      return { ok: false, ...last };
+    }
+    async function verifyEnvelope(config, envelope) {
+      if (!envelope)
+        return { verified: null };
+      if (config.verifyReceipts === false)
+        return { verified: null };
+      const token = envelope.receipt?.token;
+      if (!token)
+        return { verified: null };
+      try {
+        const r = await config.client.verifyReceipt(token);
+        const bind = (0, receipt_binding_js_1.bindReceiptToEnvelope)(envelope, r, { operation: config.operation, environment: config.environment, audience: config.audience });
+        if (bind.ok)
+          return { verified: envelope };
+        emit(config, { type: "receipt_unverified", at: iso(), decisionId: envelope.decision_id, cause: bind.detail });
+        return { verified: null, cause: bind.cause };
+      } catch {
+        return { verified: null, cause: "RECEIPT_UNVERIFIED" };
+      }
+    }
+    async function runEnforced(config, factory, approved, redacted) {
+      emit(config, { type: "execution_started", at: iso(), action: approved.action, decisionId: approved.envelope.decision_id });
+      try {
+        const result = await factory(approved.envelope, redacted);
+        return { executionAttempted: true, executed: true, enforced: true, result, verdict: approved, preflighted: true };
+      } catch (error) {
+        emit(config, { type: "factory_error", at: iso(), action: approved.action });
+        return { executionAttempted: true, executed: false, enforced: true, error, verdict: approved, preflighted: true };
+      }
+    }
+    async function runUnenforced(config, factory, envelope, verdict, preflighted, redacted) {
+      emit(config, { type: "execution_started", at: iso() });
+      try {
+        const result = await factory(envelope, redacted);
+        return { executionAttempted: true, executed: true, enforced: false, result, verdict, preflighted };
+      } catch (error) {
+        emit(config, { type: "factory_error", at: iso() });
+        return { executionAttempted: true, executed: false, enforced: false, error, verdict, preflighted };
+      }
+    }
+    function blocked(verdict, preflighted) {
+      return { executionAttempted: false, executed: false, enforced: false, verdict, preflighted };
+    }
+    function hasAnalyzableContent(artifacts) {
+      if (!Array.isArray(artifacts) || artifacts.length === 0)
+        return false;
+      return artifacts.some((a) => {
+        if (!a || typeof a !== "object")
+          return false;
+        const before = a.before;
+        const after = a.after;
+        return typeof before === "string" && before.length > 0 || typeof after === "string" && after.length > 0;
+      });
+    }
+    function unavailableVerdict(parts, count) {
+      return { kind: "UNAVAILABLE", decisionMissing: true, unavailableCount: count, ...parts };
+    }
+    async function guardToolCall(call, executeFactory, config) {
+      const failPolicy = config.failPolicy ?? "closed";
+      let redacted;
+      try {
+        redacted = config.redactor ? config.redactor(call) : call;
+      } catch {
+        breakerRecord(config);
+        return closedIntegrity(config, "CONFIG_ERROR", failPolicy);
+      }
+      const inputFp = fingerprint(redacted);
+      const detector = config.detector ?? detector_js_1.builtinDetector;
+      let detection;
+      try {
+        detection = detector.detect(redacted);
+      } catch {
+        breakerRecord(config);
+        return closedIntegrity(config, "DETECTOR_ERROR", failPolicy);
+      }
+      const suppressedByStrict = config.requireExplicitArtifacts === true && redacted.nonContract === true && (!detection.artifacts || detection.artifacts.length === 0) && detection.confident && !detection.trigger;
+      if (!detection.trigger || suppressedByStrict) {
+        emit(config, { type: "detection_skip", at: iso(), signals: detection.signals, detectorVersion: detector.version });
+        const verdict = { kind: "SKIPPED", reason: "NOT_A_CONTRACT_CALL", signals: detection.signals, detectorVersion: detector.version };
+        return runUnenforced(config, executeFactory, null, verdict, false, redacted);
+      }
+      if (!hasAnalyzableContent(detection.artifacts)) {
+        emit(config, { type: "artifact_content_missing", at: iso(), cause: "MISSING_ARTIFACT_CONTENT", signals: detection.signals });
+        const count = breakers.get(config)?.fails.length ?? 0;
+        const v = unavailableVerdict({ cause: "MISSING_ARTIFACT_CONTENT", failPolicy, resolution: "CLOSED", action: "STOP" }, count);
+        return blocked(v, false);
+      }
+      if (failPolicy === "lkg" && !config.lkg) {
+        breakerRecord(config);
+        return closedIntegrity(config, "CONFIG_ERROR", failPolicy);
+      }
+      const request = {
+        artifacts: detection.artifacts,
+        context: { operation: config.operation ?? "tool_call", environment: config.environment, audience: config.audience },
+        previous_receipt: void 0,
+        idempotency_key: void 0
+      };
+      const cap = config.maxPayloadBytes ?? 1e6;
+      if (Buffer.byteLength(JSON.stringify(request), "utf8") > cap) {
+        breakerRecord(config);
+        return closedIntegrity(config, "PAYLOAD_TOO_LARGE", failPolicy);
+      }
+      emit(config, { type: "preflight_start", at: iso() });
+      const pf = await preflightWithRetry(config, request);
+      if (!pf.ok) {
+        breakerRecord(config);
+        const count = breakers.get(config)?.fails.length ?? 1;
+        if (pf.integrity) {
+          emit(config, { type: "breaker_tripped", at: iso(), cause: pf.cause });
+          const v2 = unavailableVerdict({ cause: pf.cause, failPolicy, resolution: "CLOSED", action: "STOP" }, count);
+          return blocked(v2, false);
+        }
+        const availCause = pf.cause;
+        if (failPolicy === "open" && !breakerTripped(config)) {
+          emit(config, { type: "preflight_unavailable", at: iso(), cause: availCause, action: "CONTINUE" });
+          const v2 = unavailableVerdict({ cause: availCause, failPolicy: "open", resolution: "OPEN_PASSTHROUGH", action: "CONTINUE" }, count);
+          return runUnenforced(config, executeFactory, null, v2, false, redacted);
+        }
+        if (failPolicy === "lkg") {
+          const lkg = await tryLkg(config, inputFp);
+          if (lkg) {
+            emit(config, { type: "preflight_unavailable", at: iso(), cause: availCause, action: lkg.action });
+            const v2 = unavailableVerdict({ cause: availCause, failPolicy: "lkg", resolution: "LKG_SUBSTITUTION", action: lkg.action, lkgEnvelope: lkg.envelope }, count);
+            return runUnenforced(config, executeFactory, lkg.envelope, v2, false, redacted);
+          }
+        }
+        if (breakerTripped(config))
+          emit(config, { type: "breaker_tripped", at: iso(), cause: availCause });
+        const v = unavailableVerdict({ cause: availCause, failPolicy, resolution: "CLOSED", action: "STOP" }, count);
+        return blocked(v, false);
+      }
+      const rd = (0, sdk_1.readDecision)(pf.response);
+      if (rd.reason === "UNREADABLE_DECISION" || !rd.envelope) {
+        breakerRecord(config);
+        return closedIntegrity(config, "SCHEMA_INVALID", failPolicy);
+      }
+      const envelope = rd.envelope;
+      const expired = isExpired(envelope);
+      const bindResult = await verifyEnvelope(config, envelope);
+      const verified = bindResult.verified;
+      const receiptVerified = !!verified;
+      if (!receiptVerified)
+        emit(config, { type: "receipt_unverified", at: iso(), decisionId: envelope.decision_id });
+      emit(config, { type: "preflight_result", at: iso(), action: rd.executionAction, decisionId: envelope.decision_id });
+      if (config.verifyReceipts !== false && !receiptVerified && envelope.receipt?.token) {
+        breakerRecord(config);
+        return closedIntegrity(config, bindResult.cause ?? "RECEIPT_UNVERIFIED", failPolicy);
+      }
+      const gate = (0, enforcement_gate_js_1.evaluateEnvelope)(pf.response, envelope, rd.executionAction, detection.artifacts);
+      if (gate.verdict === "fail-closed") {
+        breakerRecord(config);
+        return closedIntegrity(config, gate.cause, failPolicy);
+      }
+      if (gate.verdict === "block-strict") {
+        return gate.decision === "BLOCK" ? blocked({ kind: "BLOCK", action: "STOP", envelope, receiptVerified }, true) : blocked({ kind: "APPROVAL", action: "REQUEST_APPROVAL", envelope, receiptVerified }, true);
+      }
+      const kind = gate.kind;
+      if (expired) {
+        breakerRecord(config);
+        return closedIntegrity(config, "SCHEMA_INVALID", failPolicy);
+      }
+      const sinkWired = !!config.onEvent;
+      if (kind === "MONITOR") {
+        if (sinkWired)
+          emit(config, { type: "monitoring_required", at: iso(), decisionId: envelope.decision_id });
+        else
+          emit(config, { type: "monitoring_unwired", at: iso(), decisionId: envelope.decision_id });
+      }
+      if (config.observeOnly) {
+        emit(config, { type: "observe_only_passthrough", at: iso(), action: rd.executionAction });
+        const verdict = kind === "ALLOW" ? { kind: "ALLOW", action: "CONTINUE", envelope, receiptVerified } : { kind: "MONITOR", action: "CONTINUE_WITH_MONITORING", envelope, receiptVerified };
+        return runUnenforced(config, executeFactory, envelope, verdict, true, redacted);
+      }
+      const enforceable = receiptVerified && (kind === "ALLOW" || sinkWired);
+      if (enforceable) {
+        const approved = kind === "ALLOW" ? { kind: "ALLOW", action: "CONTINUE", envelope, receiptVerified: true } : { kind: "MONITOR", action: "CONTINUE_WITH_MONITORING", envelope, receiptVerified: true };
+        return runEnforced(config, executeFactory, approved, redacted);
+      }
+      breakerRecord(config);
+      return closedIntegrity(config, receiptVerified ? "MONITORING_UNWIRED" : "RECEIPT_MISSING", failPolicy);
+    }
+    function closedIntegrity(config, cause, failPolicy) {
+      const count = breakers.get(config)?.fails.length ?? 1;
+      emit(config, { type: "breaker_tripped", at: iso(), cause });
+      const v = unavailableVerdict({ cause, failPolicy, resolution: "CLOSED", action: "STOP" }, count);
+      return blocked(v, false);
+    }
+    function isExpired(envelope) {
+      const exp = envelope.expires_at;
+      if (typeof exp !== "string")
+        return false;
+      const t = Date.parse(exp);
+      return Number.isFinite(t) && t < Date.now();
+    }
+    async function tryLkg(config, inputFp) {
+      if (!config.lkg)
+        return null;
+      let cached;
+      try {
+        cached = await config.lkg.get(inputFp);
+      } catch {
+        return null;
+      }
+      if (!cached)
+        return null;
+      const { verified } = await verifyEnvelope(config, cached);
+      if (!verified)
+        return null;
+      const dec = cached.decision ?? "";
+      if (dec !== "ALLOW" && dec !== "WARN")
+        return null;
+      if (isExpired(cached))
+        return null;
+      const maxAge = config.lkgMaxAgeMs ?? 9e5;
+      const evalAt = Date.parse(cached.evaluated_at);
+      if (Number.isFinite(evalAt) && Date.now() - evalAt > maxAge)
+        return null;
+      const bindings = [
+        cached.ruleset_hash,
+        cached.environment,
+        cached.operation,
+        cached.audience
+      ];
+      if (bindings.some((b) => b === void 0))
+        return null;
+      const action = dec === "ALLOW" ? "CONTINUE" : "CONTINUE_WITH_MONITORING";
+      return { envelope: verified, action };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/session-taint.js
+var require_session_taint = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/session-taint.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.SessionTaintTracker = exports2.SESSION_TAINT_VERSION = void 0;
+    exports2.pathClass = pathClass;
+    exports2.emptySessionState = emptySessionState;
+    exports2.projectState = projectState;
+    exports2.classifyCommand = classifyCommand;
+    exports2.updateSession = updateSession;
+    exports2.computeTainted = computeTainted;
+    exports2.deriveKeySignal = deriveKeySignal;
+    exports2.evaluate = evaluate;
+    exports2.SESSION_TAINT_VERSION = "session-taint/1.0.0";
+    var NON_SSOT_RE = /(^|\/)(tests?|__tests__|fixtures?|__mocks__|src\/internal)\//i;
+    var PIPELINE_SCRATCH_RE = /(^|\/)(build|\.cache|codegen|idl)(\/|$)/i;
+    var PROSE_RE = /(^|\/)(README|CHANGELOG|LICENSE)(\.\w+)?$|\.md$/i;
+    var SSOT_PATH_RE = /(^|\/)(openapi|swagger|asyncapi)[^/]*\.(ya?ml|json)$|(^|\/)mcp\.json$|\.graphql$|\.gql$|(^|\/)idl\/.*\.proto$|(^|\/)specs?\/.*\.(ya?ml|json)$|openapi\.yaml|schema\.graphql|asyncapi\.yaml/i;
+    var MIGRATION_RE = /(^|\/)migrations?\//i;
+    var CODE_OR_CONFIG_RE = /\.(ts|tsx|js|jsx)$/i;
+    var CONTRACT_CONTENT_RE = /\bopenapi\s*[:=]|\bswagger\s*[:=]|\basyncapi\s*[:=]|syntax\s*=\s*["']proto3|["']inputSchema["']|\btype\s+Query\b|(^|\n)\s*paths\s*:/i;
+    var STAGING_NAME_RE = /\.b64$|enc\/|field-map|flags\.json|optional_fields|required_fields|service\.idl|frags\/|BREAKING_DROP/i;
+    var NON_SINK_RE = /validate-frags|gen-docs|reload-flags|snapshot-spec|prettier|npm test|npm install|npx prettier/i;
+    var SSOT_INVALIDATE_RE = /archive-old-spec/i;
+    var SSOT_SINK_RE = /dsl-to-openapi|merge-spec|publish-fixture|promote-spec|sync-graphql|b64join-write|decode-promote|apply-field-map|render-openapi|idl\/compile|generate-and-test|compile_spec_bundle|install-proto|install-mcp|promote-asyncapi|repack-extract|codegen\/build\.js|codegen\/apply|codegen\/render/i;
+    function pathClass(p) {
+      if (PROSE_RE.test(p))
+        return "prose";
+      if (NON_SSOT_RE.test(p) || PIPELINE_SCRATCH_RE.test(p))
+        return "scratch";
+      if (MIGRATION_RE.test(p))
+        return "migration";
+      if (SSOT_PATH_RE.test(p))
+        return "ssot";
+      if (CODE_OR_CONFIG_RE.test(p) || p.startsWith("src/") || p.startsWith("config/") || p === "package.json")
+        return "code_or_config";
+      return "other";
+    }
+    function emptySessionState() {
+      return {
+        scratch_writes: [],
+        contract_looking_scratch: [],
+        encoded_fragments: [],
+        intermediate_artifacts: [],
+        pending_renames: [],
+        optional_fields_added: [],
+        required_fields_declared: [],
+        ssot_paths_touched: [],
+        ssot_sink_events: [],
+        ssot_invalidated: false,
+        reverse_snapshot: false,
+        formatter_only_ssot: false,
+        store_keys: [],
+        tainted: false
+      };
+    }
+    function projectState(s) {
+      return {
+        scratch_writes: s.scratch_writes.slice(),
+        encoded_fragments: s.encoded_fragments.slice(),
+        pending_renames: s.pending_renames.map((r) => "drop" in r ? `drop:${r.drop}` : `${r.from}->${r.to}`),
+        optional_fields_added: s.optional_fields_added.slice(),
+        required_fields_declared: s.required_fields_declared.slice(),
+        ssot_paths_touched: s.ssot_paths_touched.slice(),
+        contract_looking_scratch: s.contract_looking_scratch.slice(),
+        intermediate_artifacts: s.intermediate_artifacts.slice(),
+        ssot_sink_events: s.ssot_sink_events.slice(),
+        ssot_invalidated: s.ssot_invalidated,
+        reverse_snapshot: s.reverse_snapshot,
+        formatter_only_ssot: s.formatter_only_ssot,
+        store_keys: s.store_keys.slice(),
+        tainted: s.tainted
+      };
+    }
+    function asRecord(args) {
+      return args && typeof args === "object" ? args : {};
+    }
+    function extractPaths(args) {
+      const a = asRecord(args);
+      const out = [];
+      for (const k of ["path", "target", "file", "dest", "filename", "destination"])
+        if (typeof a[k] === "string")
+          out.push(a[k]);
+      return out;
+    }
+    function extractContent(args) {
+      const a = asRecord(args);
+      const parts = [];
+      for (const k of ["contents", "content", "new_string", "old_string", "patch", "value", "command"])
+        if (typeof a[k] === "string")
+          parts.push(a[k]);
+      return parts.join("\n");
+    }
+    function isEncodedFragment(path, content) {
+      if (path && /part\.|enc\/|\.b64$|pkg\.part/i.test(path))
+        return true;
+      const c = content.replace(/\s+/g, "");
+      if (c.length >= 8 && c.length < 80 && /^[A-Za-z0-9+/=]+$/.test(c))
+        return true;
+      return false;
+    }
+    function classifyCommand(command, action, cfg = {}) {
+      const s = `${command || ""} ${action || ""}`;
+      const extraNon = cfg.extraNonSinkPatterns || [];
+      const extraSink = cfg.extraSinkPatterns || [];
+      if (NON_SINK_RE.test(s) || extraNon.some((r) => r.test(s)))
+        return "non_sink";
+      if (SSOT_INVALIDATE_RE.test(s))
+        return "ssot_invalidate";
+      if (SSOT_SINK_RE.test(s) || action === "compile_spec_bundle" || extraSink.some((r) => r.test(s)))
+        return "ssot_sink";
+      if (/snapshot/i.test(s))
+        return "reverse_snapshot";
+      if (/prettier|format/i.test(s))
+        return "formatter";
+      return "unknown_script";
+    }
+    function pushUniq(arr, v) {
+      if (v != null && !arr.includes(v))
+        arr.push(v);
+    }
+    function updateSession(state, call, cfg = {}) {
+      const s = JSON.parse(JSON.stringify(state));
+      const args = asRecord(call && call.arguments);
+      const paths = extractPaths(args);
+      const content = extractContent(args);
+      const tool = call && call.toolName;
+      if (tool === "store" && typeof args.key === "string") {
+        pushUniq(s.store_keys, args.key);
+        if (/spec_|api_|openapi|schema/i.test(args.key) || /BREAKING|ROUTE|FIELD|REMOVE|MANDATORY|required|optional/i.test(String(args.value))) {
+          pushUniq(s.intermediate_artifacts, `store:${args.key}`);
+        }
+      }
+      if (tool === "apply" && typeof args.action === "string") {
+        if (classifyCommand("", args.action, cfg) === "ssot_sink")
+          s.ssot_sink_events.push(args.action);
+      }
+      if (tool === "Bash" || typeof args.command === "string") {
+        const cmd = typeof args.command === "string" ? args.command : "";
+        const kind = classifyCommand(cmd, "", cfg);
+        if (kind === "ssot_sink")
+          s.ssot_sink_events.push(cmd);
+        if (kind === "ssot_invalidate")
+          s.ssot_invalidated = true;
+        if (kind === "reverse_snapshot")
+          s.reverse_snapshot = true;
+        if (kind === "formatter" && (SSOT_PATH_RE.test(cmd) || /openapi|swagger|asyncapi|\.graphql|\.gql|mcp\.json|schema/i.test(cmd)))
+          s.formatter_only_ssot = true;
+      }
+      for (const p of paths) {
+        const pc = pathClass(p);
+        const isScratch = pc === "scratch" || NON_SSOT_RE.test(p) || PIPELINE_SCRATCH_RE.test(p);
+        if (isScratch) {
+          pushUniq(s.scratch_writes, p);
+          if (CONTRACT_CONTENT_RE.test(content) || STAGING_NAME_RE.test(p + content))
+            pushUniq(s.contract_looking_scratch, p);
+          if (PIPELINE_SCRATCH_RE.test(p))
+            pushUniq(s.intermediate_artifacts, p);
+          if (isEncodedFragment(p, content) || /\.b64$/i.test(p) || /enc\//i.test(p) || /pkg\.part/i.test(p))
+            pushUniq(s.encoded_fragments, p);
+          if (/field-map|flags\.json|optional_fields|required_fields|\.idl$/i.test(p))
+            pushUniq(s.intermediate_artifacts, p);
+        }
+        if (pc === "ssot" && !(tool === "Bash" && /prettier/i.test(typeof args.command === "string" ? args.command : "")))
+          pushUniq(s.ssot_paths_touched, p);
+        if (/field-map/i.test(p)) {
+          let obj;
+          try {
+            obj = JSON.parse(content);
+          } catch {
+            obj = null;
+          }
+          if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+            for (const [k, v] of Object.entries(obj)) {
+              if (k === "__drop" && Array.isArray(v)) {
+                for (const d of v)
+                  s.pending_renames.push({ drop: String(d) });
+              } else if (typeof v === "string")
+                s.pending_renames.push({ from: k, to: v });
+            }
+          }
+        }
+        if (/flags\.json/i.test(p)) {
+          for (const m of content.matchAll(/"(\w+)":\s*"optional"/g))
+            pushUniq(s.optional_fields_added, m[1]);
+          for (const m of content.matchAll(/"(\w+)":\s*"required"/g))
+            pushUniq(s.required_fields_declared, m[1]);
+        }
+        if (/optional_fields/i.test(p)) {
+          for (const line of content.split("\n"))
+            if (line.trim())
+              pushUniq(s.optional_fields_added, line.trim());
+        }
+        if (/required_fields/i.test(p)) {
+          for (const line of content.split("\n"))
+            if (line.trim())
+              pushUniq(s.required_fields_declared, line.trim());
+        }
+        if (NON_SSOT_RE.test(p) && /required:\s*\[[^\]]*owner_id/.test(content))
+          pushUniq(s.required_fields_declared, "owner_id");
+        if (NON_SSOT_RE.test(p) && /owner_id:\s*\{type: string\}/.test(content))
+          pushUniq(s.optional_fields_added, "owner_id");
+        if (/\.idl$/i.test(p) || p.startsWith("idl/"))
+          pushUniq(s.intermediate_artifacts, p);
+      }
+      if (/BREAKING_DROP|FIELD .* REMOVE|MANDATORY/i.test(content))
+        pushUniq(s.intermediate_artifacts, paths[0] || "inline_flag");
+      s.tainted = computeTainted(s);
+      return s;
+    }
+    function computeTainted(s) {
+      return s.contract_looking_scratch.length > 0 || s.encoded_fragments.length > 0 || s.intermediate_artifacts.length > 0 || s.store_keys.some((k) => /spec_|api_|schema|openapi/i.test(k)) || s.pending_renames.length > 0 || s.optional_fields_added.some((f) => s.required_fields_declared.includes(f)) || s.required_fields_declared.length > 0 && s.optional_fields_added.length > 0 || s.ssot_invalidated === true;
+    }
+    function deriveKeySignal(s) {
+      if (s.ssot_invalidated)
+        return "delete_recreate_ssot_via_session";
+      if (s.encoded_fragments.length)
+        return "encoded_scratch_then_ssot_promotion";
+      if (s.optional_fields_added.some((f) => s.required_fields_declared.includes(f)) || s.required_fields_declared.length && s.optional_fields_added.length)
+        return "cumulative_required_flip";
+      if (s.pending_renames.length)
+        return "cumulative_rename_via_codegen";
+      if (s.contract_looking_scratch.length)
+        return "scratch_to_ssot_promotion";
+      if (s.intermediate_artifacts.length)
+        return "cross_call_reassembly_to_ssot";
+      return "session_ssot_sink_with_taint";
+    }
+    function evaluate(state, prevFlagged = false, opts = {}) {
+      const sink = state.ssot_sink_events.length > 0 || opts.sinkSeen === true;
+      const taint = state.tainted || opts.overflow === true;
+      const flag = sink && taint;
+      return { flag, trip: flag && !prevFlagged, key_signal: flag ? deriveKeySignal(state) : null };
+    }
+    var DEF = { maxCalls: 256, maxPathsTracked: 512, maxSinkEvents: 64, maxStateBytes: 256e3, ttlMs: 36e5 };
+    var SessionTaintTracker = class {
+      version = exports2.SESSION_TAINT_VERSION;
+      state = emptySessionState();
+      prevFlag = false;
+      callCount = 0;
+      overflow = false;
+      sinkSeen = false;
+      lastObserveAt = 0;
+      cfg;
+      constructor(config = {}) {
+        this.cfg = config;
+      }
+      pathTotal() {
+        const s = this.state;
+        return s.scratch_writes.length + s.contract_looking_scratch.length + s.encoded_fragments.length + s.intermediate_artifacts.length + s.ssot_paths_touched.length;
+      }
+      observe(call) {
+        const now = this.now();
+        if (this.lastObserveAt && now - this.lastObserveAt > (this.cfg.ttlMs ?? DEF.ttlMs))
+          this.reset();
+        this.lastObserveAt = now;
+        const next = updateSession(this.state, call, this.cfg);
+        this.callCount++;
+        if (this.callCount > (this.cfg.maxCalls ?? DEF.maxCalls))
+          this.overflow = true;
+        if (this.pathTotal() > (this.cfg.maxPathsTracked ?? DEF.maxPathsTracked))
+          this.overflow = true;
+        if (JSON.stringify(next).length > (this.cfg.maxStateBytes ?? DEF.maxStateBytes))
+          this.overflow = true;
+        if (next.ssot_sink_events.length > (this.cfg.maxSinkEvents ?? DEF.maxSinkEvents)) {
+          next.ssot_sink_events = next.ssot_sink_events.slice(0, this.cfg.maxSinkEvents ?? DEF.maxSinkEvents);
+        }
+        this.state = next;
+        if (this.state.ssot_sink_events.length > 0)
+          this.sinkSeen = true;
+        return this.snapshot();
+      }
+      status() {
+        return this.snapshot();
+      }
+      reset() {
+        this.state = emptySessionState();
+        this.prevFlag = false;
+        this.callCount = 0;
+        this.overflow = false;
+        this.sinkSeen = false;
+        this.lastObserveAt = 0;
+      }
+      snapshot() {
+        const eva = evaluate(this.state, this.prevFlag, { overflow: this.overflow, sinkSeen: this.sinkSeen });
+        if (eva.flag)
+          this.prevFlag = true;
+        return {
+          flag: eva.flag,
+          trip: eva.trip,
+          key_signal: eva.key_signal,
+          state: projectState(this.state),
+          version: exports2.SESSION_TAINT_VERSION,
+          overflow: this.overflow,
+          severity: this.cfg.sessionTaintSeverity || "caution"
+        };
+      }
+      // Date.now is fine at runtime; isolated for testability.
+      now() {
+        return Date.now();
+      }
+    };
+    exports2.SessionTaintTracker = SessionTaintTracker;
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/resolver-yaml.js
+var require_resolver_yaml = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/resolver-yaml.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.YamlLiteError = void 0;
+    exports2.parseDoc = parseDoc;
+    exports2.stableStringify = stableStringify;
+    var YamlLiteError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "YamlLiteError";
+      }
+    };
+    exports2.YamlLiteError = YamlLiteError;
+    function parseDoc(text) {
+      const trimmed = text.trimStart();
+      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+          return JSON.parse(text);
+        } catch (e) {
+          throw new YamlLiteError(`invalid JSON: ${e.message}`);
+        }
+      }
+      const lines = [];
+      for (const raw of text.split("\n")) {
+        const trimmedLine = raw.trim();
+        if (trimmedLine === "" || trimmedLine.startsWith("#"))
+          continue;
+        lines.push({ indent: raw.length - raw.trimStart().length, text: trimmedLine });
+      }
+      if (lines.length === 0)
+        return null;
+      const [value] = parseBlock(lines, 0, lines[0].indent);
+      return value;
+    }
+    function parseBlock(lines, start, indent) {
+      if (start >= lines.length)
+        return [null, start];
+      const first = lines[start];
+      if (first.text === "-" || first.text.startsWith("- "))
+        return parseSequence(lines, start, indent);
+      return parseMapping(lines, start, indent);
+    }
+    function parseMapping(lines, start, indent) {
+      const obj = {};
+      let i = start;
+      while (i < lines.length && lines[i].indent === indent) {
+        const { key, rest } = splitKeyValue(lines[i].text);
+        i += 1;
+        if (rest === "") {
+          if (i < lines.length && lines[i].indent > indent) {
+            const [child, next] = parseBlock(lines, i, lines[i].indent);
+            obj[key] = child;
+            i = next;
+          } else {
+            obj[key] = null;
+          }
+        } else {
+          obj[key] = parseScalarOrFlow(rest);
+        }
+      }
+      return [obj, i];
+    }
+    function parseSequence(lines, start, indent) {
+      const arr = [];
+      let i = start;
+      while (i < lines.length && lines[i].indent === indent && (lines[i].text === "-" || lines[i].text.startsWith("- "))) {
+        const itemText = lines[i].text.slice(1).trim();
+        i += 1;
+        if (itemText === "") {
+          if (i < lines.length && lines[i].indent > indent) {
+            const [child, next] = parseBlock(lines, i, lines[i].indent);
+            arr.push(child);
+            i = next;
+          } else {
+            arr.push(null);
+          }
+        } else {
+          arr.push(parseScalarOrFlow(itemText));
+        }
+      }
+      return [arr, i];
+    }
+    function splitKeyValue(text) {
+      let key;
+      let idx;
+      if (text[0] === "'" || text[0] === '"') {
+        const q = text[0];
+        let j = 1;
+        while (j < text.length && text[j] !== q)
+          j += 1;
+        key = text.slice(1, j);
+        idx = text.indexOf(":", j);
+      } else {
+        idx = text.indexOf(":");
+        key = idx === -1 ? text : text.slice(0, idx);
+      }
+      if (idx === -1)
+        return { key: key.trim(), rest: "" };
+      return { key: key.trim(), rest: text.slice(idx + 1).trim() };
+    }
+    function parseScalarOrFlow(s) {
+      const t = s.trim();
+      if (t === "" || t === "~" || t === "null")
+        return null;
+      if (t[0] === "{" || t[0] === "[")
+        return parseFlow(t).value;
+      if (t[0] === "'" || t[0] === '"')
+        return unquote(t);
+      return t;
+    }
+    function unquote(t) {
+      const q = t[0];
+      let j = 1;
+      let out = "";
+      while (j < t.length && t[j] !== q) {
+        out += t[j];
+        j += 1;
+      }
+      return out;
+    }
+    function parseFlow(s) {
+      if (s[0] === "{")
+        return parseFlowMap(s);
+      if (s[0] === "[")
+        return parseFlowSeq(s);
+      throw new YamlLiteError(`not a flow collection: ${s.slice(0, 20)}`);
+    }
+    function parseFlowMap(s) {
+      const obj = {};
+      let i = 1;
+      while (i < s.length) {
+        while (i < s.length && (s[i] === " " || s[i] === ","))
+          i += 1;
+        if (s[i] === "}")
+          return { value: obj, end: i + 1 };
+        let key;
+        if (s[i] === "'" || s[i] === '"') {
+          const q = s[i];
+          let j = i + 1;
+          let k = "";
+          while (j < s.length && s[j] !== q) {
+            k += s[j];
+            j += 1;
+          }
+          key = k;
+          i = j + 1;
+        } else {
+          let k = "";
+          while (i < s.length && s[i] !== ":" && s[i] !== "}" && s[i] !== ",") {
+            k += s[i];
+            i += 1;
+          }
+          key = k.trim();
+        }
+        while (i < s.length && (s[i] === " " || s[i] === ":"))
+          i += 1;
+        const [val, next] = readFlowValue(s, i);
+        obj[key] = val;
+        i = next;
+      }
+      throw new YamlLiteError(`unterminated flow map: ${s.slice(0, 40)}`);
+    }
+    function parseFlowSeq(s) {
+      const arr = [];
+      let i = 1;
+      while (i < s.length) {
+        while (i < s.length && (s[i] === " " || s[i] === ","))
+          i += 1;
+        if (s[i] === "]")
+          return { value: arr, end: i + 1 };
+        const [val, next] = readFlowValue(s, i);
+        arr.push(val);
+        i = next;
+      }
+      throw new YamlLiteError(`unterminated flow seq: ${s.slice(0, 40)}`);
+    }
+    function readFlowValue(s, start) {
+      let i = start;
+      while (i < s.length && s[i] === " ")
+        i += 1;
+      if (s[i] === "{" || s[i] === "[") {
+        const { value, end } = parseFlow(s.slice(i));
+        return [value, i + end];
+      }
+      if (s[i] === "'" || s[i] === '"') {
+        const q = s[i];
+        let j = i + 1;
+        let out2 = "";
+        while (j < s.length && s[j] !== q) {
+          out2 += s[j];
+          j += 1;
+        }
+        return [out2, j + 1];
+      }
+      let out = "";
+      while (i < s.length && s[i] !== "," && s[i] !== "}" && s[i] !== "]") {
+        out += s[i];
+        i += 1;
+      }
+      return [out.trim(), i];
+    }
+    function stableStringify(value) {
+      return JSON.stringify(sortKeys(value));
+    }
+    function sortKeys(value) {
+      if (Array.isArray(value))
+        return value.map(sortKeys);
+      if (value && typeof value === "object") {
+        const out = {};
+        for (const k of Object.keys(value).sort()) {
+          out[k] = sortKeys(value[k]);
+        }
+        return out;
+      }
+      return value;
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/resolver-glob.js
+var require_resolver_glob = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/resolver-glob.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.globToRegExp = globToRegExp;
+    exports2.matchGlob = matchGlob;
+    exports2.matchAny = matchAny;
+    exports2.firstMatchIndex = firstMatchIndex;
+    function globToRegExp(glob) {
+      let re = "";
+      for (let i = 0; i < glob.length; i += 1) {
+        const c = glob[i];
+        if (c === "*") {
+          if (glob[i + 1] === "*") {
+            i += 1;
+            if (glob[i + 1] === "/") {
+              re += "(?:.*/)?";
+              i += 1;
+            } else {
+              re += ".*";
+            }
+          } else {
+            re += "[^/]*";
+          }
+        } else if (c === "?") {
+          re += "[^/]";
+        } else if (".+^${}()|[]\\".includes(c)) {
+          re += `\\${c}`;
+        } else {
+          re += c;
+        }
+      }
+      return new RegExp(`^${re}$`);
+    }
+    function matchGlob(glob, path) {
+      return globToRegExp(glob).test(path);
+    }
+    function matchAny(globs, path) {
+      if (!Array.isArray(globs))
+        return false;
+      return globs.some((g) => g === path || matchGlob(g, path));
+    }
+    function firstMatchIndex(globs, path) {
+      if (!Array.isArray(globs))
+        return -1;
+      for (let i = 0; i < globs.length; i += 1) {
+        if (globs[i] === path || matchGlob(globs[i], path))
+          return i;
+      }
+      return -1;
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/artifact-resolver.js
+var require_artifact_resolver = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/artifact-resolver.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolve = resolve;
+    var resolver_yaml_js_1 = require_resolver_yaml();
+    var resolver_glob_js_1 = require_resolver_glob();
+    var DEFAULT_GENERATED = ["**/generated/**", "**/gen/**"];
+    var VENDOR_GLOBS = ["**/node_modules/**", "**/vendor/**"];
+    function normalizePath(p) {
+      let s = p.replace(/\\/g, "/").trim();
+      while (s.startsWith("./"))
+        s = s.slice(2);
+      return s;
+    }
+    function dirname(p) {
+      const i = p.lastIndexOf("/");
+      return i === -1 ? "" : p.slice(0, i);
+    }
+    function basename(p) {
+      const i = p.lastIndexOf("/");
+      return i === -1 ? p : p.slice(i + 1);
+    }
+    function extname(p) {
+      const b = basename(p);
+      const i = b.lastIndexOf(".");
+      return i === -1 ? "" : b.slice(i + 1).toLowerCase();
+    }
+    function resolveRelative(dir, rel) {
+      const parts = (dir ? dir.split("/") : []).concat(normalizePath(rel).split("/"));
+      const out = [];
+      for (const seg of parts) {
+        if (seg === "" || seg === ".")
+          continue;
+        if (seg === "..")
+          out.pop();
+        else
+          out.push(seg);
+      }
+      return out.join("/");
+    }
+    function classifyByName(path) {
+      const b = basename(path).toLowerCase();
+      const ext = extname(path);
+      const yamlJson = ext === "yaml" || ext === "yml" || ext === "json";
+      if (yamlJson && (b.includes("openapi") || b.includes("swagger")))
+        return "openapi";
+      if (yamlJson && b.includes("asyncapi"))
+        return "asyncapi";
+      if (ext === "graphql" || ext === "gql")
+        return "graphql";
+      if (ext === "proto")
+        return "grpc";
+      if (b === "mcp.json" || b === "tools-catalog.json")
+        return "mcp_manifest";
+      return null;
+    }
+    function classifyByContent(text) {
+      if (!text)
+        return null;
+      if (/(^|\n)\s*["']?openapi["']?\s*:\s*["']?[23]/.test(text) || /swagger\s*:/.test(text) && /paths\s*:/.test(text))
+        return "openapi";
+      if (/(^|\n)\s*["']?asyncapi["']?\s*:/.test(text))
+        return "asyncapi";
+      if (/\btype\s+Query\b|\btype\s+Mutation\b|\bschema\s*\{/.test(text))
+        return "graphql";
+      if (/syntax\s*=\s*["']proto[23]["']/.test(text))
+        return "grpc";
+      try {
+        const j = JSON.parse(text);
+        if (j && Array.isArray(j.tools) && j.tools.some((t) => t && typeof t === "object" && "inputSchema" in t))
+          return "mcp_manifest";
+      } catch {
+      }
+      return null;
+    }
+    function isMcpByNameNeedingContent(path) {
+      const b = basename(path).toLowerCase();
+      return extname(path) === "json" && b.includes("mcp") && b !== "mcp.json";
+    }
+    var REF_RE = /\$ref["']?\s*:\s*["']?([^"'\s,}]+)["']?/g;
+    function scanRefs(text) {
+      const out = [];
+      let m;
+      REF_RE.lastIndex = 0;
+      while ((m = REF_RE.exec(text)) !== null)
+        out.push(m[1]);
+      return out;
+    }
+    function isExternalRef(ref) {
+      return /^[a-z][a-z0-9+.-]*:\/\//i.test(ref) || ref.startsWith("//");
+    }
+    function isInternalRef(ref) {
+      return ref.startsWith("#");
+    }
+    function splitRef(ref) {
+      const i = ref.indexOf("#");
+      return i === -1 ? { file: ref, pointer: "" } : { file: ref.slice(0, i), pointer: ref.slice(i + 1) };
+    }
+    function jsonPointer(doc, pointer) {
+      if (pointer === "" || pointer === "/")
+        return doc;
+      const parts = pointer.replace(/^\//, "").split("/").map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+      let cur = doc;
+      for (const part of parts) {
+        if (cur && typeof cur === "object" && part in cur)
+          cur = cur[part];
+        else
+          return void 0;
+      }
+      return cur;
+    }
+    function slugify(s) {
+      return s.replace(/[^A-Za-z0-9]+/g, "_");
+    }
+    var RefError = class extends Error {
+      reason;
+      related;
+      constructor(reason, related) {
+        super(reason);
+        this.reason = reason;
+        this.related = related;
+      }
+    };
+    function assembleSide(rootPath, rootText, refSide, input, config, deps) {
+      const maxDepth = config.maxRefDepth ?? 8;
+      let root;
+      try {
+        root = (0, resolver_yaml_js_1.parseDoc)(rootText);
+      } catch (e) {
+        if (e instanceof resolver_yaml_js_1.YamlLiteError)
+          throw new RefError("parse_error");
+        throw e;
+      }
+      const components = {};
+      const inline = (node, curDir, depth, stack) => {
+        if (Array.isArray(node))
+          return node.map((n) => inline(n, curDir, depth, stack));
+        if (node && typeof node === "object") {
+          const rec = node;
+          if (typeof rec.$ref === "string") {
+            const ref = rec.$ref;
+            if (isExternalRef(ref))
+              throw new RefError("external_ref_forbidden");
+            if (isInternalRef(ref))
+              return { ...rec };
+            const { file, pointer } = splitRef(ref);
+            const targetPath = resolveRelative(curDir, file);
+            const key = `${targetPath}#${pointer}`;
+            if (depth + 1 > maxDepth)
+              throw new RefError("ref_depth_exceeded", targetPath);
+            if (stack.has(key))
+              throw new RefError("ref_cycle", targetPath);
+            const blob = getBlob(input, refSide, targetPath);
+            if (blob === null || blob === void 0)
+              throw new RefError("missing_ref_target", targetPath);
+            if (typeof blob === "object")
+              throw new RefError(blob.error, targetPath);
+            deps.add(targetPath);
+            let targetDoc;
+            try {
+              targetDoc = (0, resolver_yaml_js_1.parseDoc)(blob);
+            } catch {
+              throw new RefError("parse_error", targetPath);
+            }
+            const resolved = jsonPointer(targetDoc, pointer);
+            if (resolved === void 0)
+              throw new RefError("missing_ref_target", targetPath);
+            const inlined = inline(resolved, dirname(targetPath), depth + 1, /* @__PURE__ */ new Set([...stack, key]));
+            const slug = slugify(`${targetPath}__${pointer}`);
+            components[slug] = inlined;
+            return { $ref: `#/components/${slug}` };
+          }
+          const out = {};
+          for (const k of Object.keys(rec))
+            out[k] = inline(rec[k], curDir, depth, stack);
+          return out;
+        }
+        return node;
+      };
+      const inlinedRoot = inline(root, dirname(rootPath), 0, /* @__PURE__ */ new Set());
+      if (Object.keys(components).length > 0) {
+        const existing = inlinedRoot.components && typeof inlinedRoot.components === "object" ? inlinedRoot.components : {};
+        inlinedRoot.components = { ...existing, ...components };
+      }
+      return (0, resolver_yaml_js_1.stableStringify)(inlinedRoot);
+    }
+    function getBlob(input, ref, path) {
+      return input.blobs[`${ref}:${path}`];
+    }
+    function loadRoot(path, type, input, config) {
+      const baseBlob = getBlob(input, input.baseRef, path);
+      const headBlob = getBlob(input, input.headRef, path);
+      if (baseBlob && typeof baseBlob === "object")
+        return { unresolved: { path, reason: baseBlob.error } };
+      if (headBlob && typeof headBlob === "object")
+        return { unresolved: { path, reason: headBlob.error } };
+      const baseNull = baseBlob === null || baseBlob === void 0;
+      const headNull = headBlob === null || headBlob === void 0;
+      if (baseNull && headNull)
+        return { unresolved: { path, reason: "empty_changed_contract" } };
+      let before = baseNull ? "" : baseBlob;
+      let after = headNull ? "" : headBlob;
+      const deps = /* @__PURE__ */ new Set();
+      const assemble = (type === "openapi" || type === "asyncapi") && (config.openApiAssembly ?? "bundle_inline") === "bundle_inline";
+      if (assemble) {
+        try {
+          if (before !== "" && scanRefs(before).some((r) => !isInternalRef(r)))
+            before = assembleSide(path, before, input.baseRef, input, config, deps);
+          if (after !== "" && scanRefs(after).some((r) => !isInternalRef(r)))
+            after = assembleSide(path, after, input.headRef, input, config, deps);
+        } catch (e) {
+          if (e instanceof RefError)
+            return { unresolved: { path, reason: e.reason, ...e.related ? { related_paths: [e.related] } : {} } };
+          throw e;
+        }
+      }
+      const id = input.repository ? `${input.repository}:${type}:${path}` : `${type}:${path}`;
+      return { artifact: { id, type, before, after }, deps: [...deps] };
+    }
+    function selectGroups(candidates, config, generatedGlobs) {
+      const n = candidates.length;
+      const parent = Array.from({ length: n }, (_, i) => i);
+      const find = (x) => {
+        while (parent[x] !== x) {
+          parent[x] = parent[parent[x]];
+          x = parent[x];
+        }
+        return x;
+      };
+      const union = (a, b) => {
+        const ra = find(a);
+        const rb = find(b);
+        if (ra !== rb)
+          parent[Math.max(ra, rb)] = Math.min(ra, rb);
+      };
+      if (Array.isArray(config.forceSameSurfaceGroup)) {
+        const idxs = candidates.map((c, i) => config.forceSameSurfaceGroup.includes(c.path) ? i : -1).filter((i) => i >= 0);
+        for (let k = 1; k < idxs.length; k += 1)
+          union(idxs[0], idxs[k]);
+      }
+      const byType = /* @__PURE__ */ new Map();
+      candidates.forEach((c, i) => {
+        const a = byType.get(c.type) ?? [];
+        a.push(i);
+        byType.set(c.type, a);
+      });
+      for (const idxs of byType.values()) {
+        const gen = idxs.filter((i) => (0, resolver_glob_js_1.matchAny)(generatedGlobs, candidates[i].path));
+        if (gen.length > 0 && gen.length < idxs.length)
+          for (let k = 1; k < idxs.length; k += 1)
+            union(idxs[0], idxs[k]);
+      }
+      const groups = /* @__PURE__ */ new Map();
+      for (let i = 0; i < n; i += 1) {
+        const r = find(i);
+        const g = groups.get(r) ?? [];
+        g.push(i);
+        groups.set(r, g);
+      }
+      const selections = [];
+      const chosen = [];
+      const ambiguous = [];
+      for (const g of groups.values()) {
+        const members = g.map((i) => candidates[i].path).sort();
+        if (members.length === 1) {
+          chosen.push(candidates[g[0]]);
+          selections.push({ chosen: members[0], deferred: [], reason: "single" });
+          continue;
+        }
+        const prefRanked = members.map((p) => ({ p, rank: (0, resolver_glob_js_1.firstMatchIndex)(config.ssotPrefer, p) })).filter((x) => x.rank >= 0);
+        if (prefRanked.length > 0) {
+          prefRanked.sort((a, b) => a.rank - b.rank || (a.p < b.p ? -1 : 1));
+          const chosenPath = prefRanked[0].p;
+          chosen.push(candidates[g.find((i) => candidates[i].path === chosenPath)]);
+          selections.push({ chosen: chosenPath, deferred: members.filter((m) => m !== chosenPath), reason: "ssotPrefer" });
+          continue;
+        }
+        const nongen = members.filter((p) => !(0, resolver_glob_js_1.matchAny)(generatedGlobs, p));
+        if (nongen.length === 1) {
+          const chosenPath = nongen[0];
+          chosen.push(candidates[g.find((i) => candidates[i].path === chosenPath)]);
+          selections.push({ chosen: chosenPath, deferred: members.filter((m) => m !== chosenPath), reason: "generated_deprioritized" });
+          continue;
+        }
+        ambiguous.push(...members);
+      }
+      return { selections, chosen, ambiguous };
+    }
+    function resolve(input, config = {}) {
+      const generatedGlobs = config.generatedGlobs ?? DEFAULT_GENERATED;
+      const seen = /* @__PURE__ */ new Set();
+      const paths = [];
+      for (const raw of Array.isArray(input.changedFiles) ? input.changedFiles : []) {
+        const p = normalizePath(raw);
+        if (p && !seen.has(p)) {
+          seen.add(p);
+          paths.push(p);
+        }
+      }
+      const candidates = [];
+      const ignored = [];
+      for (const p of paths) {
+        if ((0, resolver_glob_js_1.matchAny)(VENDOR_GLOBS, p)) {
+          ignored.push(p);
+          continue;
+        }
+        let type = config.pathTypeHints?.[p] ?? classifyByName(p);
+        if (type === null || isMcpByNameNeedingContent(p)) {
+          const peek = firstDefinedText(getBlob(input, input.headRef, p), getBlob(input, input.baseRef, p));
+          const sniff = classifyByContent(peek);
+          if (isMcpByNameNeedingContent(p))
+            type = sniff === "mcp_manifest" ? "mcp_manifest" : type ?? sniff;
+          else
+            type = sniff;
+        }
+        if (type)
+          candidates.push({ path: p, type });
+        else
+          ignored.push(p);
+      }
+      const unresolved = [];
+      let effectiveCandidates = candidates;
+      if (config.requireSsotIfConfigured && Array.isArray(config.ssotPrefer)) {
+        const missing = config.ssotPrefer.filter((pref) => !hasGlobChar(pref) && !existsInTree(input, pref));
+        const hasGenerated = candidates.some((c) => (0, resolver_glob_js_1.matchAny)(generatedGlobs, c.path));
+        if (missing.length > 0 && hasGenerated) {
+          for (const pref of missing)
+            unresolved.push({ path: pref, reason: "config_ssot_missing" });
+          effectiveCandidates = candidates.filter((c) => !(0, resolver_glob_js_1.matchAny)(generatedGlobs, c.path));
+        }
+      }
+      const { selections, chosen, ambiguous } = selectGroups(effectiveCandidates, config, generatedGlobs);
+      for (const p of [...new Set(ambiguous)].sort())
+        unresolved.push({ path: p, reason: "ambiguous_ssot" });
+      const artifacts = [];
+      const selBySel = new Map(selections.map((s) => [s.chosen, s]));
+      for (const c of chosen.slice().sort((a, b) => a.path < b.path ? -1 : 1)) {
+        const res = loadRoot(c.path, c.type, input, config);
+        if ("artifact" in res) {
+          artifacts.push(res.artifact);
+          const sel = selBySel.get(c.path);
+          for (const dep of res.deps) {
+            const idx = ignored.indexOf(dep);
+            if (idx >= 0)
+              ignored.splice(idx, 1);
+            if (sel && !sel.deferred.includes(dep) && dep !== c.path)
+              sel.deferred.push(dep);
+          }
+          if (sel)
+            sel.deferred.sort();
+        } else {
+          unresolved.push(res.unresolved);
+        }
+      }
+      const A = artifacts.length;
+      const U = unresolved.length;
+      const chosenCount = chosen.length;
+      let coverage;
+      if (chosenCount === 0 && U === 0)
+        coverage = "EMPTY";
+      else if (U === 0 && A >= 1 && A === chosenCount)
+        coverage = "COMPLETE";
+      else if (A >= 1 && U >= 1)
+        coverage = "PARTIAL";
+      else
+        coverage = "UNRESOLVED";
+      artifacts.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+      unresolved.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : a.reason < b.reason ? -1 : a.reason > b.reason ? 1 : 0);
+      ignored.sort();
+      const contractDiscovered = effectiveCandidates.map((c) => c.path).slice().sort();
+      return {
+        artifacts,
+        unresolved,
+        coverage,
+        report: {
+          version: "artifact-resolver-report/1.0",
+          baseRef: input.baseRef,
+          headRef: input.headRef,
+          contract_paths_discovered: contractDiscovered,
+          ignored_non_contract: ignored,
+          ssot_selections: selections,
+          claim: {
+            artifacts_ready_for_preflight: coverage === "COMPLETE" || coverage === "EMPTY",
+            produces_verdict: false
+          }
+        }
+      };
+    }
+    function firstDefinedText(...vals) {
+      for (const v of vals)
+        if (typeof v === "string")
+          return v;
+      return void 0;
+    }
+    function hasGlobChar(p) {
+      return /[*?]/.test(p);
+    }
+    function existsInTree(input, path) {
+      return typeof getBlob(input, input.baseRef, path) === "string" || typeof getBlob(input, input.headRef, path) === "string";
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/tool-registry.js
+var require_tool_registry = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/tool-registry.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.RegistryConstructionError = void 0;
+    exports2.guardToolRegistry = guardToolRegistry;
+    var guard_js_1 = require_guard();
+    var RegistryConstructionError = class extends Error {
+      code;
+      toolName;
+      constructor(code, message, toolName) {
+        super(message);
+        this.name = "RegistryConstructionError";
+        this.code = code;
+        this.toolName = toolName;
+      }
+    };
+    exports2.RegistryConstructionError = RegistryConstructionError;
+    var MUTATING_GENERIC = ["write", "edit", "create", "update", "delete", "remove", "apply_patch", "applypatch", "str_replace", "notebook_edit", "multi_edit", "insert"];
+    var MUTATING_SHELL = ["bash", "shell", "terminal", "run_command", "exec", "powershell"];
+    var MUTATING_VCS = ["git_commit", "git_push", "git_merge", "commit", "push"];
+    var MUTATING_DEPLOY = ["deploy", "kubectl_apply", "helm_upgrade", "release"];
+    var MUTATING_PUBLISH = ["npm_publish", "publish_package", "twine_upload", "cargo_publish"];
+    var MUTATING_SCHEMA = ["register_tools", "update_manifest", "mcp_register"];
+    var READONLY = ["read", "grep", "glob", "search", "list", "ls", "cat", "get", "fetch", "web_search", "browser_navigate"];
+    function isMutatingClass(cls) {
+      return cls !== "readonly";
+    }
+    function matchesAny(hay, patterns) {
+      return patterns.some((p) => hay.includes(p));
+    }
+    function heuristicClass(name) {
+      const n = String(name || "").toLowerCase();
+      if (matchesAny(n, MUTATING_SHELL))
+        return "mutating_shell";
+      if (matchesAny(n, MUTATING_VCS) || n.startsWith("git_"))
+        return "mutating_vcs";
+      if (matchesAny(n, MUTATING_DEPLOY))
+        return "mutating_deploy";
+      if (matchesAny(n, MUTATING_PUBLISH))
+        return "mutating_publish";
+      if (matchesAny(n, MUTATING_SCHEMA))
+        return "mutating_schema";
+      if (matchesAny(n, MUTATING_GENERIC))
+        return "mutating";
+      if (matchesAny(n, READONLY))
+        return "readonly";
+      return null;
+    }
+    function resolveClass(tool, config, unknownPolicy) {
+      const classify = config.classify || {};
+      if (Object.prototype.hasOwnProperty.call(classify, tool.name))
+        return { cls: classify[tool.name], source: "classify" };
+      if (tool.mutationClass)
+        return { cls: tool.mutationClass, source: "mutationClass" };
+      if (Array.isArray(config.forceReadonly) && config.forceReadonly.includes(tool.name))
+        return { cls: "readonly", source: "forceReadonly" };
+      const h = heuristicClass(tool.name);
+      if (h)
+        return { cls: h, source: "heuristic" };
+      if (unknownPolicy === "reject") {
+        throw new RegistryConstructionError("UNKNOWN_TOOL", `tool '${tool.name}' is unclassified and unknownToolPolicy='reject'`, tool.name);
+      }
+      return { cls: unknownPolicy === "readonly" ? "readonly" : "mutating", source: "unknown" };
+    }
+    function operationForClass(cls, name, guardOperation) {
+      switch (cls) {
+        case "mutating_shell":
+          return "tool_call";
+        case "mutating_vcs":
+          return /merge/i.test(name) ? "merge" : "tool_call";
+        case "mutating_deploy":
+          return "deploy";
+        case "mutating_publish":
+          return "publish";
+        case "mutating_schema":
+          return "tool_call";
+        case "mutating":
+        default:
+          return guardOperation ?? "tool_call";
+      }
+    }
+    function defaultBinder(tool, args) {
+      return { toolName: tool.name, arguments: args };
+    }
+    var RAW_EXECUTORS = /* @__PURE__ */ new WeakMap();
+    function freezeTool(t) {
+      Object.freeze(t._coderifts);
+      return Object.freeze(t);
+    }
+    function passthroughProtected(tool, cls) {
+      const rawExecute = tool.execute;
+      const protectedTool = {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        meta: tool.meta,
+        execute: async (args) => rawExecute(args),
+        // new function, not === rawExecute
+        _coderifts: { guarded: false, mutationClass: cls }
+      };
+      RAW_EXECUTORS.set(protectedTool, rawExecute);
+      return freezeTool(protectedTool);
+    }
+    function wrapWithGuard(tool, cls, config) {
+      const rawExecute = tool.execute;
+      const guardBase = config.guard;
+      const operation = operationForClass(cls, tool.name, guardBase.operation);
+      const guardCfg = { ...guardBase, operation };
+      const binder = config.binders && config.binders[tool.name] || ((t, a) => defaultBinder(t, a));
+      const protectedTool = {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        meta: tool.meta,
+        execute: async (args) => {
+          const call = binder(tool, args, cls);
+          return (0, guard_js_1.guardToolCall)(call, async (_envelope, redacted) => rawExecute(redacted ? redacted.arguments : args), guardCfg);
+        },
+        _coderifts: { guarded: true, mutationClass: cls, operation }
+      };
+      RAW_EXECUTORS.set(protectedTool, rawExecute);
+      return freezeTool(protectedTool);
+    }
+    function guardToolRegistry(rawTools, config = {}) {
+      const failHard = config.failOnUnguardedMutator !== false;
+      const unknownPolicy = config.unknownToolPolicy ?? "mutating";
+      const input = Array.isArray(rawTools) ? rawTools : [];
+      for (const tool of input) {
+        if (!tool || typeof tool.name !== "string" || tool.name.trim() === "") {
+          throw new RegistryConstructionError("INVALID_TOOL", "a tool has a missing or empty name");
+        }
+        if (typeof tool.execute !== "function") {
+          throw new RegistryConstructionError("INVALID_TOOL", `tool '${tool.name}' has no execute function`, tool.name);
+        }
+      }
+      const seen = /* @__PURE__ */ new Set();
+      for (const tool of input) {
+        if (seen.has(tool.name)) {
+          throw new RegistryConstructionError("DUPLICATE_TOOL_NAME", `duplicate tool name '${tool.name}'`, tool.name);
+        }
+        seen.add(tool.name);
+      }
+      const sorted = input.slice().sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+      const guardedMutators = [];
+      const readonlyPassthrough = [];
+      const warnings = [];
+      const staged = [];
+      let anyForced = false;
+      let anyUnknownReadonly = false;
+      for (const tool of sorted) {
+        const { cls, source } = resolveClass(tool, config, unknownPolicy);
+        const forced = cls === "readonly" && (source === "classify" || source === "forceReadonly") && isMutating(heuristicClass(tool.name));
+        if (forced) {
+          anyForced = true;
+          warnings.push(`force_readonly_on_mutator_heuristic:${tool.name}`);
+        }
+        if (source === "unknown" && cls === "readonly")
+          anyUnknownReadonly = true;
+        staged.push({ tool, cls, forced });
+      }
+      if (anyForced && failHard) {
+        throw new RegistryConstructionError("FORCE_READONLY_MUTATOR", `forceReadonly/classify downgraded a heuristic mutator to readonly while failOnUnguardedMutator is true`);
+      }
+      const willWrap = staged.some((s) => isMutating(s.cls) && !s.forced);
+      const validGuard = !!(config.guard && config.guard.client);
+      if (willWrap && !validGuard) {
+        throw new RegistryConstructionError("GUARD_CONFIG_INVALID", "a mutating tool is present but config.guard.client is missing/invalid");
+      }
+      const protectedTools = [];
+      for (const { tool, cls, forced } of staged) {
+        if (cls === "readonly") {
+          readonlyPassthrough.push(tool.name);
+          protectedTools.push(passthroughProtected(tool, "readonly"));
+        } else {
+          guardedMutators.push(tool.name);
+          protectedTools.push(wrapWithGuard(tool, cls, config));
+        }
+        void forced;
+      }
+      for (const p of protectedTools) {
+        if (isMutatingClass(p._coderifts.mutationClass) && p._coderifts.guarded !== true) {
+          throw new RegistryConstructionError("GUARD_CONFIG_INVALID", `invariant violated: '${p.name}' is a mutator exposed without a guard`, p.name);
+        }
+      }
+      const M = guardedMutators.length;
+      const G = guardedMutators.length;
+      let coverage;
+      if (anyForced) {
+        coverage = "BYPASSED";
+      } else if (unknownPolicy === "readonly" && anyUnknownReadonly) {
+        coverage = "PARTIAL";
+      } else if (M === G) {
+        coverage = "COMPLETE";
+      } else {
+        coverage = "PARTIAL";
+      }
+      if (unknownPolicy === "readonly" && anyUnknownReadonly && !warnings.includes("unknown_treated_as_readonly")) {
+        warnings.push("unknown_treated_as_readonly");
+      }
+      const inescapableRuntime = coverage === "COMPLETE" && failHard;
+      const report = {
+        version: "guard-tool-registry-report/1.0",
+        coverage,
+        protected_tools: protectedTools.map((p) => p.name),
+        guarded_mutators: guardedMutators.slice(),
+        readonly_passthrough: readonlyPassthrough.slice(),
+        unguarded_mutators: [],
+        // strict impl: always [] (COMPLETE ⇒ [] by G4; forced tools are readonly)
+        unknown_treated_as: unknownPolicy,
+        claim: {
+          inescapable_runtime: inescapableRuntime,
+          inescapable_merge: false,
+          inescapable_deploy: false
+        },
+        siblings: {
+          merge_gate: "required_separate_#7",
+          artifact_resolver: "sibling_#4"
+        },
+        warnings
+      };
+      Object.freeze(report.claim);
+      Object.freeze(report.siblings);
+      Object.freeze(report);
+      return {
+        tools: Object.freeze(protectedTools),
+        coverage,
+        report
+      };
+    }
+    function isMutating(cls) {
+      return cls != null && cls !== "readonly";
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/merge-gate.js
+var require_merge_gate = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/merge-gate.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.gateDecision = gateDecision;
+    function normSha(s) {
+      return String(s == null ? "" : s).trim().toLowerCase();
+    }
+    function normOp(o) {
+      return String(o == null ? "" : o).trim().toLowerCase();
+    }
+    function sameHead(a, b, allowPrefix) {
+      const na = normSha(a);
+      const nb = normSha(b);
+      if (!na || !nb)
+        return false;
+      if (na === nb)
+        return true;
+      if (allowPrefix && na.length >= 7 && nb.length >= 7 && (na.startsWith(nb) || nb.startsWith(na)))
+        return true;
+      return false;
+    }
+    function isAllowClass(receipt, allowWarnMerge) {
+      const dec = receipt.decision;
+      const decisionOk = dec === "ALLOW" || dec === "WARN" && allowWarnMerge === true;
+      if (!decisionOk)
+        return false;
+      const ea = receipt.execution_action;
+      if (ea === void 0 || ea === null || ea === "")
+        return true;
+      return ea === "CONTINUE" || ea === "CONTINUE_WITH_MONITORING";
+    }
+    function targetMatches(targetId, repository) {
+      const t = String(targetId).toLowerCase();
+      const r = String(repository).toLowerCase();
+      return t === r || t === `repo:${r}` || t.endsWith(`:${r}`) || t.endsWith(`/${r}`);
+    }
+    function gateDecision(input) {
+      const rc = input.requiredContext || {};
+      const protection = rc.protection || { enforcement: "UNKNOWN", admin_bypass_possible: true };
+      const enforcement_state = protection.enforcement;
+      const allowPending = input.allowPending ?? rc.allowPending ?? false;
+      const allowWarnMerge = input.allowWarnMerge ?? rc.allowWarnMerge ?? false;
+      const allowPrefix = input.allowPrefixCompare ?? rc.allowPrefixCompare ?? false;
+      const receipt = input.receipt;
+      const detail = {
+        prHeadSha: normSha(input.prHeadSha),
+        bound_head_sha: receipt ? normSha(receipt.bound_head_sha) : null,
+        decision: receipt ? String(receipt.decision) : null
+      };
+      const fail = (state, reason) => ({
+        merge_allowed: false,
+        state,
+        reason,
+        enforcement_state,
+        inescapable_merge: false,
+        detail
+      });
+      if (!input.prHeadSha || String(input.prHeadSha).trim() === "") {
+        return fail(allowPending ? "pending" : "failure", "inputs_incomplete");
+      }
+      if (receipt === null || receipt === void 0) {
+        return fail(allowPending ? "pending" : "failure", "no_receipt");
+      }
+      if (receipt.currently_authorized !== true) {
+        return fail("failure", "receipt_not_authorized");
+      }
+      const op = rc.operation ?? "merge";
+      if (receipt.operation == null || normOp(receipt.operation) !== normOp(op)) {
+        return fail("failure", "operation_mismatch");
+      }
+      if (!sameHead(receipt.bound_head_sha, input.prHeadSha, allowPrefix)) {
+        return fail("failure", "stale_head");
+      }
+      if (rc.expected_fingerprint != null && receipt.verdict_fingerprint !== rc.expected_fingerprint) {
+        return fail("failure", "fingerprint_mismatch");
+      }
+      if (rc.expected_body_hash != null && receipt.body_hash !== rc.expected_body_hash) {
+        return fail("failure", "body_hash_mismatch");
+      }
+      if (rc.repository && receipt.target_id && !targetMatches(receipt.target_id, rc.repository)) {
+        return fail("failure", "target_mismatch");
+      }
+      if (!isAllowClass(receipt, allowWarnMerge)) {
+        return fail("failure", "decision_not_allow");
+      }
+      const inescapable_merge = enforcement_state === "ENFORCING" && protection.admin_bypass_possible === false;
+      let residual;
+      if (!inescapable_merge) {
+        if (enforcement_state === "ENFORCING")
+          residual = "admin_bypass_open";
+        else if (enforcement_state === "ADVISORY")
+          residual = "protection_advisory_only";
+        else
+          residual = "protection_not_configured";
+      }
+      return {
+        merge_allowed: true,
+        state: "success",
+        reason: "allow_current_head",
+        enforcement_state,
+        inescapable_merge,
+        ...residual ? { residual } : {},
+        detail
+      };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/deploy-gate.js
+var require_deploy_gate = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/deploy-gate.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.deployGate = deployGate;
+    function norm(s) {
+      return String(s == null ? "" : s).trim().toLowerCase();
+    }
+    function sameNorm(a, b, allowPrefix) {
+      const na = norm(a);
+      const nb = norm(b);
+      if (!na || !nb)
+        return false;
+      if (na === nb)
+        return true;
+      if (allowPrefix && na.length >= 7 && nb.length >= 7 && (na.startsWith(nb) || nb.startsWith(na)))
+        return true;
+      return false;
+    }
+    function isAllowClass(receipt, allowWarnDeploy) {
+      const dec = receipt.decision;
+      const decisionOk = dec === "ALLOW" || dec === "WARN" && allowWarnDeploy === true;
+      if (!decisionOk)
+        return false;
+      const ea = receipt.execution_action;
+      if (ea === void 0 || ea === null || ea === "")
+        return true;
+      return ea === "CONTINUE" || ea === "CONTINUE_WITH_MONITORING";
+    }
+    function idMatchesName(targetId, name) {
+      const t = norm(targetId);
+      const r = norm(name);
+      return t === r || t === `svc:${r}` || t === `repo:${r}` || t.endsWith(`:${r}`) || t.endsWith(`/${r}`);
+    }
+    function deployGate(input) {
+      const target = input.deployTarget || {};
+      const rc = input.requiredContext || {};
+      const enf = rc.enforcement || { enforcement: "UNKNOWN", bypass_possible: true };
+      const enforcement_state = enf.enforcement;
+      const opRequired = rc.operation ?? "deploy";
+      const requireEnv = rc.require_bound_environment !== false;
+      const requireArt = rc.require_bound_artifact !== false;
+      const allowPending = input.allowPending ?? rc.allowPending ?? false;
+      const allowWarnDeploy = input.allowWarnDeploy ?? rc.allowWarnDeploy ?? false;
+      const allowPrefix = input.allowPrefixCompare ?? rc.allowPrefixCompare ?? false;
+      const receipt = input.receipt;
+      const detail = {
+        environment: norm(target.environment),
+        artifact_id: norm(target.artifact_id),
+        bound_environment: receipt && receipt.bound_environment != null ? norm(receipt.bound_environment) : null,
+        bound_artifact_id: receipt && receipt.bound_artifact_id != null ? norm(receipt.bound_artifact_id) : null,
+        operation: receipt && receipt.operation != null ? String(receipt.operation) : null
+      };
+      const deny = (state, reason) => ({
+        deploy_allowed: false,
+        state,
+        reason,
+        enforcement_state,
+        inescapable_deploy: false,
+        detail
+      });
+      if (!target.environment || String(target.environment).trim() === "" || !target.artifact_id || String(target.artifact_id).trim() === "") {
+        return deny(allowPending ? "pending" : "failure", "inputs_incomplete");
+      }
+      if (receipt === null || receipt === void 0) {
+        return deny(allowPending ? "pending" : "failure", "no_receipt");
+      }
+      if (receipt.currently_authorized !== true) {
+        return deny("failure", "receipt_not_authorized");
+      }
+      if (receipt.operation == null || norm(receipt.operation) !== norm(opRequired)) {
+        return deny("failure", "operation_mismatch");
+      }
+      if (requireEnv) {
+        if (!receipt.bound_environment || !sameNorm(receipt.bound_environment, target.environment, allowPrefix)) {
+          return deny("failure", "env_mismatch");
+        }
+      } else if (receipt.bound_environment && !sameNorm(receipt.bound_environment, target.environment, allowPrefix)) {
+        return deny("failure", "env_mismatch");
+      }
+      if (requireArt) {
+        if (!receipt.bound_artifact_id || !sameNorm(receipt.bound_artifact_id, target.artifact_id, allowPrefix)) {
+          return deny("failure", "stale_artifact");
+        }
+      } else if (receipt.bound_artifact_id && !sameNorm(receipt.bound_artifact_id, target.artifact_id, allowPrefix)) {
+        return deny("failure", "stale_artifact");
+      }
+      if (rc.expected_fingerprint != null && receipt.verdict_fingerprint !== rc.expected_fingerprint) {
+        return deny("failure", "fingerprint_mismatch");
+      }
+      if (rc.expected_body_hash != null && receipt.body_hash !== rc.expected_body_hash) {
+        return deny("failure", "body_hash_mismatch");
+      }
+      if (rc.service && receipt.target_id) {
+        if (!idMatchesName(receipt.target_id, rc.service))
+          return deny("failure", "target_mismatch");
+      } else if (rc.repository && receipt.target_id) {
+        if (!idMatchesName(receipt.target_id, rc.repository))
+          return deny("failure", "target_mismatch");
+      }
+      if (!isAllowClass(receipt, allowWarnDeploy)) {
+        return deny("failure", "decision_not_allow");
+      }
+      const inescapable_deploy = enforcement_state === "ENFORCING" && enf.bypass_possible === false;
+      let residual;
+      if (!inescapable_deploy) {
+        if (enforcement_state === "ENFORCING")
+          residual = "bypass_open";
+        else
+          residual = "enforcement_not_configured";
+      }
+      return {
+        deploy_allowed: true,
+        state: "success",
+        reason: "allow_current_deploy",
+        enforcement_state,
+        inescapable_deploy,
+        ...residual ? { residual } : {},
+        detail
+      };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/coverage-report.js
+var require_coverage_report = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/coverage-report.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.coverageReport = coverageReport;
+    var TEMPLATES = {
+      claim_fully_enforced: "All applicable CodeRifts placements are enforcing and non-bypassable for this target. Residuals outside tetrad (e.g. infra break-glass) may still exist.",
+      claim_partially_enforced: "Partial enforcement: some applicable placements enforce; open gaps: {residuals}.",
+      claim_advisory_only: "CodeRifts is present but no applicable placement is fully enforcing. Gaps: {residuals}.",
+      claim_content_blocked: "Contract artifact content is not fully resolved; enforcement of preflight content is incomplete. Gaps: {residuals}.",
+      claim_unknown: "One or more applicable placements cannot be observed. Cannot attest full enforcement. Gaps: {residuals}.",
+      claim_not_applicable: "No CodeRifts placements are in scope for this target."
+    };
+    var OVERALL_TO_KEY = {
+      FULLY_ENFORCED: "claim_fully_enforced",
+      PARTIALLY_ENFORCED: "claim_partially_enforced",
+      ADVISORY_ONLY: "claim_advisory_only",
+      CONTENT_BLOCKED: "claim_content_blocked",
+      UNKNOWN: "claim_unknown",
+      NOT_APPLICABLE: "claim_not_applicable"
+    };
+    function computeRuntime(applicable, input) {
+      if (!applicable)
+        return { strength: "EXCLUDED", residuals: [], summary: { enforcement_or_coverage: input?.coverage ?? "N/A", inescapable_flag: input?.inescapable_runtime ?? null } };
+      if (input == null)
+        return { strength: "UNKNOWN", residuals: ["runtime_state_missing"], summary: { enforcement_or_coverage: "MISSING", inescapable_flag: null } };
+      const residuals = [...input.residuals ?? []];
+      let strength;
+      if (input.coverage === "COMPLETE" && input.inescapable_runtime === true)
+        strength = "ENFORCING";
+      else if (input.coverage === "UNKNOWN")
+        strength = "UNKNOWN";
+      else
+        strength = "WEAK";
+      if (input.coverage === "BYPASSED")
+        residuals.push("runtime_bypassed");
+      return { strength, residuals, summary: { enforcement_or_coverage: input.coverage, inescapable_flag: input.inescapable_runtime } };
+    }
+    function computeMerge(applicable, input) {
+      if (!applicable)
+        return { strength: "EXCLUDED", residuals: [], summary: { enforcement_or_coverage: input?.enforcement_state ?? "N/A", inescapable_flag: input?.inescapable_merge ?? null } };
+      if (input == null)
+        return { strength: "UNKNOWN", residuals: ["merge_state_missing"], summary: { enforcement_or_coverage: "MISSING", inescapable_flag: null } };
+      const residuals = [...input.residuals ?? []];
+      let strength;
+      if (input.inescapable_merge === true && input.enforcement_state === "ENFORCING")
+        strength = "ENFORCING";
+      else if (input.inescapable_merge === true) {
+        strength = "WEAK";
+        residuals.push("inescapable_flag_inconsistent");
+      } else if (input.enforcement_state === "UNKNOWN")
+        strength = "UNKNOWN";
+      else
+        strength = "WEAK";
+      if (strength === "WEAK") {
+        if (input.enforcement_state === "ENFORCING" && input.inescapable_merge === false)
+          residuals.push("admin_bypass_open");
+        else if (input.enforcement_state === "ABSENT")
+          residuals.push("merge_gate_not_configured");
+        else if (input.enforcement_state === "ADVISORY")
+          residuals.push("merge_gate_advisory");
+      }
+      return { strength, residuals, summary: { enforcement_or_coverage: input.enforcement_state, inescapable_flag: input.inescapable_merge } };
+    }
+    function computeDeploy(applicable, input) {
+      if (!applicable)
+        return { strength: "EXCLUDED", residuals: [], summary: { enforcement_or_coverage: input?.enforcement_state ?? "N/A", inescapable_flag: input?.inescapable_deploy ?? null } };
+      if (input == null)
+        return { strength: "UNKNOWN", residuals: ["deploy_state_missing"], summary: { enforcement_or_coverage: "MISSING", inescapable_flag: null } };
+      const residuals = [...input.residuals ?? []];
+      let strength;
+      if (input.inescapable_deploy === true && input.enforcement_state === "ENFORCING")
+        strength = "ENFORCING";
+      else if (input.inescapable_deploy === true) {
+        strength = "WEAK";
+        residuals.push("inescapable_flag_inconsistent");
+      } else if (input.enforcement_state === "UNKNOWN")
+        strength = "UNKNOWN";
+      else
+        strength = "WEAK";
+      if (strength === "WEAK") {
+        if (input.enforcement_state === "ENFORCING" && input.inescapable_deploy === false)
+          residuals.push("bypass_open");
+        else if (input.enforcement_state === "ABSENT")
+          residuals.push("deploy_path_ungated");
+        else if (input.enforcement_state === "ADVISORY")
+          residuals.push("deploy_gate_advisory");
+      }
+      return { strength, residuals, summary: { enforcement_or_coverage: input.enforcement_state, inescapable_flag: input.inescapable_deploy } };
+    }
+    function computeContent(applicable, input) {
+      if (!applicable)
+        return { strength: "EXCLUDED", residuals: [], summary: { enforcement_or_coverage: input?.coverage ?? "N/A", inescapable_flag: input?.artifacts_ready ?? null } };
+      if (input == null)
+        return { strength: "UNKNOWN", residuals: ["content_state_missing"], summary: { enforcement_or_coverage: "MISSING", inescapable_flag: null } };
+      const residuals = [...input.residuals ?? []];
+      let strength;
+      if (input.coverage === "COMPLETE" || input.coverage === "EMPTY")
+        strength = "ENFORCING";
+      else if (input.coverage === "UNRESOLVED") {
+        strength = "WEAK";
+        residuals.push("content_unresolved");
+      } else if (input.coverage === "PARTIAL") {
+        strength = "WEAK";
+        residuals.push("content_partial");
+      } else
+        strength = "UNKNOWN";
+      return { strength, residuals, summary: { enforcement_or_coverage: input.coverage, inescapable_flag: input.artifacts_ready ?? null } };
+    }
+    function coverageReport(input) {
+      const applicability = input.applicability || { runtime: false, merge: false, deploy: false, content: false };
+      const computed = {
+        runtime: computeRuntime(applicability.runtime === true, input.runtime),
+        merge: computeMerge(applicability.merge === true, input.merge),
+        deploy: computeDeploy(applicability.deploy === true, input.deploy),
+        content: computeContent(applicability.content === true, input.content)
+      };
+      const order = ["runtime", "merge", "deploy", "content"];
+      const isApplicable = (p) => applicability[p] === true;
+      const applicableStrengths = order.filter(isApplicable).map((p) => computed[p].strength);
+      const contentApplicable = isApplicable("content");
+      const contentUnresolved = contentApplicable && input.content != null && input.content.coverage === "UNRESOLVED";
+      const weakPlacements = order.filter((p) => isApplicable(p) && computed[p].strength === "WEAK");
+      let overall;
+      if (applicableStrengths.length === 0) {
+        overall = "NOT_APPLICABLE";
+      } else if (applicableStrengths.every((s) => s === "ENFORCING")) {
+        overall = "FULLY_ENFORCED";
+      } else if (applicableStrengths.some((s) => s === "WEAK") && applicableStrengths.some((s) => s === "ENFORCING")) {
+        overall = contentUnresolved ? "CONTENT_BLOCKED" : "PARTIALLY_ENFORCED";
+      } else if (applicableStrengths.some((s) => s === "WEAK")) {
+        overall = contentUnresolved && weakPlacements.every((p) => p === "content") ? "CONTENT_BLOCKED" : "ADVISORY_ONLY";
+      } else {
+        overall = "UNKNOWN";
+      }
+      const residualSet = /* @__PURE__ */ new Set();
+      for (const p of order)
+        if (isApplicable(p))
+          for (const r of computed[p].residuals)
+            residualSet.add(r);
+      const residuals = [...residualSet].sort();
+      const honest_claim_key = OVERALL_TO_KEY[overall];
+      const honest_claim_language = TEMPLATES[honest_claim_key].replace("{residuals}", residuals.length ? residuals.join(", ") : "none");
+      const flags = {
+        may_claim_inescapable_runtime: isApplicable("runtime") && computed.runtime.strength === "ENFORCING",
+        may_claim_inescapable_merge: isApplicable("merge") && computed.merge.strength === "ENFORCING",
+        may_claim_inescapable_deploy: isApplicable("deploy") && computed.deploy.strength === "ENFORCING",
+        may_claim_full_tetrad: overall === "FULLY_ENFORCED"
+      };
+      const per_placement = order.map((p) => ({
+        placement: p,
+        applicable: isApplicable(p),
+        strength: computed[p].strength,
+        summary: computed[p].summary,
+        residuals: isApplicable(p) ? [...new Set(computed[p].residuals)].sort() : []
+      }));
+      return { overall_coverage: overall, per_placement, residuals, honest_claim_key, honest_claim_language, flags };
+    }
+  }
+});
+
+// ../../node_modules/@coderifts/agent-guard/dist/cjs/index.js
+var require_cjs4 = __commonJS({
+  "../../node_modules/@coderifts/agent-guard/dist/cjs/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.coverageReport = exports2.deployGate = exports2.gateDecision = exports2.RegistryConstructionError = exports2.guardToolRegistry = exports2.globToRegExp = exports2.matchGlob = exports2.resolveArtifacts = exports2.deriveKeySignal = exports2.pathClass = exports2.classifyCommand = exports2.projectState = exports2.emptySessionState = exports2.computeTainted = exports2.evaluate = exports2.updateSession = exports2.SESSION_TAINT_VERSION = exports2.SessionTaintTracker = exports2.readDecision = exports2.computeBundleFingerprint = exports2.computeArtifactDigest = exports2.evaluateEnvelope = exports2.canonicalJson = exports2.computeBodyHash = exports2.bindReceiptToEnvelope = exports2.DETECTOR_VERSION = exports2.builtinDetector = exports2.guardToolCall = void 0;
+    var guard_js_1 = require_guard();
+    Object.defineProperty(exports2, "guardToolCall", { enumerable: true, get: function() {
+      return guard_js_1.guardToolCall;
+    } });
+    var detector_js_1 = require_detector();
+    Object.defineProperty(exports2, "builtinDetector", { enumerable: true, get: function() {
+      return detector_js_1.builtinDetector;
+    } });
+    Object.defineProperty(exports2, "DETECTOR_VERSION", { enumerable: true, get: function() {
+      return detector_js_1.DETECTOR_VERSION;
+    } });
+    var receipt_binding_js_1 = require_receipt_binding();
+    Object.defineProperty(exports2, "bindReceiptToEnvelope", { enumerable: true, get: function() {
+      return receipt_binding_js_1.bindReceiptToEnvelope;
+    } });
+    Object.defineProperty(exports2, "computeBodyHash", { enumerable: true, get: function() {
+      return receipt_binding_js_1.computeBodyHash;
+    } });
+    Object.defineProperty(exports2, "canonicalJson", { enumerable: true, get: function() {
+      return receipt_binding_js_1.canonicalJson;
+    } });
+    var enforcement_gate_js_1 = require_enforcement_gate();
+    Object.defineProperty(exports2, "evaluateEnvelope", { enumerable: true, get: function() {
+      return enforcement_gate_js_1.evaluateEnvelope;
+    } });
+    Object.defineProperty(exports2, "computeArtifactDigest", { enumerable: true, get: function() {
+      return enforcement_gate_js_1.computeArtifactDigest;
+    } });
+    Object.defineProperty(exports2, "computeBundleFingerprint", { enumerable: true, get: function() {
+      return enforcement_gate_js_1.computeBundleFingerprint;
+    } });
+    var sdk_1 = require_cjs3();
+    Object.defineProperty(exports2, "readDecision", { enumerable: true, get: function() {
+      return sdk_1.readDecision;
+    } });
+    var session_taint_js_1 = require_session_taint();
+    Object.defineProperty(exports2, "SessionTaintTracker", { enumerable: true, get: function() {
+      return session_taint_js_1.SessionTaintTracker;
+    } });
+    Object.defineProperty(exports2, "SESSION_TAINT_VERSION", { enumerable: true, get: function() {
+      return session_taint_js_1.SESSION_TAINT_VERSION;
+    } });
+    Object.defineProperty(exports2, "updateSession", { enumerable: true, get: function() {
+      return session_taint_js_1.updateSession;
+    } });
+    Object.defineProperty(exports2, "evaluate", { enumerable: true, get: function() {
+      return session_taint_js_1.evaluate;
+    } });
+    Object.defineProperty(exports2, "computeTainted", { enumerable: true, get: function() {
+      return session_taint_js_1.computeTainted;
+    } });
+    Object.defineProperty(exports2, "emptySessionState", { enumerable: true, get: function() {
+      return session_taint_js_1.emptySessionState;
+    } });
+    Object.defineProperty(exports2, "projectState", { enumerable: true, get: function() {
+      return session_taint_js_1.projectState;
+    } });
+    Object.defineProperty(exports2, "classifyCommand", { enumerable: true, get: function() {
+      return session_taint_js_1.classifyCommand;
+    } });
+    Object.defineProperty(exports2, "pathClass", { enumerable: true, get: function() {
+      return session_taint_js_1.pathClass;
+    } });
+    Object.defineProperty(exports2, "deriveKeySignal", { enumerable: true, get: function() {
+      return session_taint_js_1.deriveKeySignal;
+    } });
+    var artifact_resolver_js_1 = require_artifact_resolver();
+    Object.defineProperty(exports2, "resolveArtifacts", { enumerable: true, get: function() {
+      return artifact_resolver_js_1.resolve;
+    } });
+    var resolver_glob_js_1 = require_resolver_glob();
+    Object.defineProperty(exports2, "matchGlob", { enumerable: true, get: function() {
+      return resolver_glob_js_1.matchGlob;
+    } });
+    Object.defineProperty(exports2, "globToRegExp", { enumerable: true, get: function() {
+      return resolver_glob_js_1.globToRegExp;
+    } });
+    var tool_registry_js_1 = require_tool_registry();
+    Object.defineProperty(exports2, "guardToolRegistry", { enumerable: true, get: function() {
+      return tool_registry_js_1.guardToolRegistry;
+    } });
+    Object.defineProperty(exports2, "RegistryConstructionError", { enumerable: true, get: function() {
+      return tool_registry_js_1.RegistryConstructionError;
+    } });
+    var merge_gate_js_1 = require_merge_gate();
+    Object.defineProperty(exports2, "gateDecision", { enumerable: true, get: function() {
+      return merge_gate_js_1.gateDecision;
+    } });
+    var deploy_gate_js_1 = require_deploy_gate();
+    Object.defineProperty(exports2, "deployGate", { enumerable: true, get: function() {
+      return deploy_gate_js_1.deployGate;
+    } });
+    var coverage_report_js_1 = require_coverage_report();
+    Object.defineProperty(exports2, "coverageReport", { enumerable: true, get: function() {
+      return coverage_report_js_1.coverageReport;
+    } });
+  }
+});
+
+// src/commands/deploy-gate.js
+var require_deploy_gate2 = __commonJS({
+  "src/commands/deploy-gate.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var chalk = require_source();
+    var { deployGate } = require_cjs4();
+    var { renderJson } = require_json2();
+    if (process.env.NO_COLOR) chalk.level = 0;
+    var REPAIRABLE = /* @__PURE__ */ new Set(["env_mismatch", "stale_artifact", "operation_mismatch", "receipt_not_authorized", "fingerprint_mismatch", "body_hash_mismatch"]);
+    function enforceSignal(options) {
+      return options && options.enforce === true || String(process.env.CODERIFTS_DEPLOY_ENFORCE || "").toLowerCase() === "true";
+    }
+    function observeCDEnforcement(options = {}) {
+      const envVal = String(process.env.CODERIFTS_DEPLOY_ENFORCE || "").toLowerCase();
+      let enforcement;
+      if (enforceSignal(options)) enforcement = "ENFORCING";
+      else if (envVal === "unknown") enforcement = "UNKNOWN";
+      else enforcement = "ADVISORY";
+      const bypass_possible = String(process.env.CODERIFTS_DEPLOY_NO_BYPASS || "").toLowerCase() !== "true";
+      return {
+        enforcement,
+        bypass_possible,
+        step_is_required: enforcement === "ENFORCING",
+        required_step_name: "CodeRifts / deploy-gate",
+        attestation_source: "cli_flag"
+      };
+    }
+    function deployReportResiduals(state, inescapable, enforcement) {
+      const out = [];
+      if (state === "success" && inescapable !== true) {
+        if (enforcement === "ENFORCING") out.push("bypass_open");
+        else if (enforcement === "ADVISORY") out.push("deploy_gate_advisory");
+        else if (enforcement === "ABSENT") out.push("deploy_path_ungated");
+      }
+      return out;
+    }
+    function deployCoverageInput(enforcement_state, inescapable_deploy) {
+      return { enforcement_state, inescapable_deploy: inescapable_deploy === true, applicability_attested: true };
+    }
+    function deployBind({ environment, artifact_id, receipt, observed_cd_enforcement, expected_fingerprint, expected_body_hash }) {
+      const attested_enforcement = observed_cd_enforcement && observed_cd_enforcement.enforcement || "UNKNOWN";
+      if (!receipt) {
+        return {
+          deploy_check_status: "pending",
+          reason: "no_receipt",
+          must_re_preflight: true,
+          attested_enforcement,
+          gate: null,
+          report_residuals: [],
+          coverage_deploy_input: deployCoverageInput(attested_enforcement, false)
+        };
+      }
+      const requiredContext = {
+        operation: "deploy",
+        enforcement: {
+          enforcement: attested_enforcement,
+          // fail-closed: bypass is possible unless observation proved it disabled.
+          bypass_possible: !(observed_cd_enforcement && observed_cd_enforcement.bypass_possible === false)
+        }
+      };
+      if (attested_enforcement === "ENFORCING") {
+        if (expected_fingerprint != null) requiredContext.expected_fingerprint = expected_fingerprint;
+        if (expected_body_hash != null) requiredContext.expected_body_hash = expected_body_hash;
+      }
+      const gate = deployGate({ deployTarget: { environment, artifact_id }, receipt, requiredContext });
+      const inescapable_deploy = gate.inescapable_deploy === true;
+      return {
+        deploy_check_status: gate.state,
+        reason: gate.reason,
+        must_re_preflight: REPAIRABLE.has(gate.reason),
+        attested_enforcement,
+        gate: { deploy_allowed: gate.deploy_allowed, reason: gate.reason, inescapable_deploy },
+        report_residuals: deployReportResiduals(gate.state, inescapable_deploy, attested_enforcement),
+        coverage_deploy_input: deployCoverageInput(attested_enforcement, inescapable_deploy)
+      };
+    }
+    function clampExit(deployCheckStatus, enforce) {
+      if (deployCheckStatus === "success") return 0;
+      if (deployCheckStatus === "failure" && enforce === true) return 1;
+      return 0;
+    }
+    function readReceiptFile(filePath) {
+      if (!filePath) return null;
+      const resolved = path.resolve(filePath);
+      if (!fs.existsSync(resolved)) return null;
+      try {
+        return JSON.parse(fs.readFileSync(resolved, "utf-8"));
+      } catch (_) {
+        return null;
+      }
+    }
+    function renderDeployGateTerminal(bind, enforce) {
+      const g = bind.gate;
+      const color = bind.deploy_check_status === "success" ? chalk.green : bind.deploy_check_status === "failure" ? chalk.red : chalk.yellow;
+      const lines = [];
+      lines.push("");
+      lines.push(chalk.bold(`  CodeRifts deploy-gate \u2014 ${color(bind.deploy_check_status.toUpperCase())}`));
+      lines.push(`  Reason:             ${bind.reason}`);
+      lines.push(`  Enforcement:        ${bind.attested_enforcement}`);
+      lines.push(`  inescapable_deploy: ${g ? g.inescapable_deploy : false}`);
+      if (bind.report_residuals.length) lines.push(`  Residuals:          ${bind.report_residuals.join(", ")}`);
+      if (bind.must_re_preflight) lines.push(chalk.yellow("  Action: re-preflight this { environment, artifact } \u2014 the receipt does not authorize it."));
+      lines.push("");
+      lines.push(enforce ? chalk.dim("  Enforcing \u2014 a failing gate exits non-zero (blocks the deploy step).") : chalk.dim("  Advisory (phase 1) \u2014 does not block the deploy (exit 0)."));
+      lines.push("");
+      return lines.join("\n");
+    }
+    async function runDeployGate(options = {}) {
+      const environment = options.env;
+      const artifactId = options.artifact;
+      if (!environment || !artifactId) {
+        console.error(chalk.red("Error: --env and --artifact are required."));
+        process.exit(1);
+        return;
+      }
+      const enforce = enforceSignal(options);
+      const receipt = readReceiptFile(options.receipt);
+      const observed = observeCDEnforcement({ enforce });
+      const bind = deployBind({ environment, artifact_id: artifactId, receipt, observed_cd_enforcement: observed });
+      const code = clampExit(bind.deploy_check_status, enforce);
+      if (options.json) {
+        console.log(renderJson({ command: "deploy-gate", environment, artifact_id: artifactId, phase: enforce ? "enforcing" : "advisory", exit_code: code, ...bind }));
+      } else {
+        console.log(renderDeployGateTerminal(bind, enforce));
+      }
+      process.exit(code);
+    }
+    module2.exports = {
+      runDeployGate,
+      deployBind,
+      observeCDEnforcement,
+      clampExit,
+      readReceiptFile,
+      renderDeployGateTerminal
+    };
+  }
+});
+
 // src/commands/init.js
 var require_init = __commonJS({
   "src/commands/init.js"(exports2, module2) {
@@ -76068,7 +79330,7 @@ var require_zipWith = __commonJS({
 });
 
 // node_modules/rxjs/dist/cjs/index.js
-var require_cjs3 = __commonJS({
+var require_cjs5 = __commonJS({
   "node_modules/rxjs/dist/cjs/index.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
@@ -77385,7 +80647,7 @@ var require_run_async = __commonJS({
 var require_utils3 = __commonJS({
   "node_modules/inquirer/lib/utils/utils.js"(exports2) {
     "use strict";
-    var { from, of } = require_cjs3();
+    var { from, of } = require_cjs5();
     var runAsync = require_run_async();
     exports2.fetchAsyncQuestionProperty = function(question, prop, answers) {
       if (typeof question[prop] !== "function") {
@@ -77410,7 +80672,7 @@ var require_prompt = __commonJS({
       get: require_get2(),
       set: require_set3()
     };
-    var { defer, empty, from, of } = require_cjs3();
+    var { defer, empty, from, of } = require_cjs5();
     var { concatMap, filter, publish, reduce } = require_operators();
     var runAsync = require_run_async();
     var utils = require_utils3();
@@ -80124,7 +83386,7 @@ var require_base = __commonJS({
 var require_events = __commonJS({
   "node_modules/inquirer/lib/utils/events.js"(exports2, module2) {
     "use strict";
-    var { fromEvent } = require_cjs3();
+    var { fromEvent } = require_cjs5();
     var { filter, map, share, takeUntil } = require_operators();
     function normalizeKeypressEvents(value, key) {
       return { value, key: key || {} };
@@ -90922,7 +94184,7 @@ var require_editor = __commonJS({
     var { editAsync } = require_commonjs();
     var Base = require_base();
     var observe = require_events();
-    var { Subject } = require_cjs3();
+    var { Subject } = require_cjs5();
     var EditorPrompt = class extends Base {
       /**
        * Start the Inquiry session
@@ -93140,6 +96402,10 @@ program.command("diff <old-spec> <new-spec>").description("Compare two OpenAPI s
   const { diff } = require_diff();
   await diff(oldSpec, newSpec, options);
 });
+program.command("deploy-gate").description("Gate a deploy on the current { environment, artifact } using a preflight receipt (phase-1 advisory)").option("--env <environment>", "Target environment (e.g. production, staging)").option("--artifact <artifact_id>", "Immutable artifact identity being deployed (content digest or commit SHA)").option("--receipt <file>", "Path to the deploy-scoped receipt JSON produced by preflight").option("--json", "Output the binding result as JSON").option("--enforce", "Treat the step as enforcing: attest ENFORCING and exit non-zero on a gate failure").action(async (options) => {
+  const { runDeployGate } = require_deploy_gate2();
+  await runDeployGate(options);
+});
 program.command("init [template]").description("Generate a .coderifts.yml from a policy template (startup, growth, fintech, public-api, microservices)").action(async (template) => {
   const { init } = require_init();
   await init(template);