coderifts 4.4.0 → 4.4.1

package/dist/cli.js

@@ -3028,7 +3028,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "coderifts",
-      version: "4.4.0",
+      version: "4.4.1",
       description: "Detect breaking API changes from the command line. Works locally or with the CodeRifts cloud API.",
       author: "CodeRifts <hello@coderifts.com>",
       license: "MIT",
@@ -3073,7 +3073,7 @@ var require_package = __commonJS({
         test: "node --test test/*.test.js"
       },
       dependencies: {
-        "@coderifts/agent-guard": "^8.1.1",
+        "@coderifts/agent-guard": "^9.0.0",
         chalk: "^4.1.2",
         "cli-table3": "^0.6.4",
         commander: "^12.0.0",
@@ -61936,7 +61936,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 = {
@@ -61959,7 +61959,7 @@ var require_axios = __commonJS({
     var platform$1 = {
       isNode: true,
       classes: {
-        URLSearchParams,
+        URLSearchParams: URLSearchParams2,
         FormData: FormData$1,
         Blob: typeof Blob !== "undefined" && Blob || null
       },
@@ -65643,6 +65643,17 @@ var require_read_decision = __commonJS({
       }
       return null;
     }
+    function isV2Response(r, envObj) {
+      if (envObj)
+        return true;
+      if (r.preflight_mode != null && r.preflight_mode !== "")
+        return true;
+      const ver = r.decision_spec_version;
+      return typeof ver === "string" && ver.startsWith("2.");
+    }
+    function allowLegacyDecisionMap(r, envObj) {
+      return r.decision_spec_version === "1.0" && !isV2Response(r, envObj);
+    }
     function readDecision(response) {
       if (!response || typeof response !== "object") {
         return { executionAction: "STOP", decision: null, reason: "UNREADABLE_DECISION" };
@@ -65696,32 +65707,34 @@ var require_read_decision = __commonJS({
         }
         return out;
       }
-      const topDecision = decisionOf(r.decision);
-      if (topDecision && Object.prototype.hasOwnProperty.call(DECISION_TO_ACTION, topDecision)) {
-        const out = {
-          executionAction: DECISION_TO_ACTION[topDecision],
-          decision: topDecision
-        };
-        if (envObj) {
-          out.envelope = asEnvelope(envObj);
-          out.receipt = receiptOf(envObj);
+      if (allowLegacyDecisionMap(r, envObj)) {
+        const topDecision = decisionOf(r.decision);
+        if (topDecision && Object.prototype.hasOwnProperty.call(DECISION_TO_ACTION, topDecision)) {
+          return {
+            executionAction: DECISION_TO_ACTION[topDecision],
+            decision: topDecision
+          };
+        }
+        const envDecision = envObj ? decisionOf(envObj.decision) : null;
+        if (envDecision && Object.prototype.hasOwnProperty.call(DECISION_TO_ACTION, envDecision)) {
+          return {
+            executionAction: DECISION_TO_ACTION[envDecision],
+            decision: envDecision,
+            envelope: envObj ? asEnvelope(envObj) : void 0,
+            receipt: envObj ? receiptOf(envObj) : void 0
+          };
         }
-        return out;
-      }
-      const envDecision = envObj ? decisionOf(envObj.decision) : null;
-      if (envDecision && Object.prototype.hasOwnProperty.call(DECISION_TO_ACTION, envDecision)) {
-        return {
-          executionAction: DECISION_TO_ACTION[envDecision],
-          decision: envDecision,
-          envelope: envObj ? asEnvelope(envObj) : void 0,
-          receipt: envObj ? receiptOf(envObj) : void 0
-        };
       }
-      return {
+      const unreadable = {
         executionAction: "STOP",
         decision: decisionOf(r.decision, envObj?.decision),
         reason: "UNREADABLE_DECISION"
       };
+      if (envObj) {
+        unreadable.envelope = asEnvelope(envObj);
+        unreadable.receipt = receiptOf(envObj);
+      }
+      return unreadable;
     }
   }
 });
@@ -66550,7 +66563,8 @@ var require_execution_proof = __commonJS({
       change_fp_is_what_was_checked_not_what_executed: true,
       calls_outside_guarded_path_invisible: true,
       execution_result_hash_is_not_artifact_match_proof: true,
-      conditional_write_is_host_asserted_not_cas_verified: true
+      conditional_write_is_host_asserted_not_cas_verified: true,
+      commit_observation_is_observed_at_t3_not_atomic: true
     });
     function assertEnforcedReceiptInvariant(input) {
       if (input.enforced === true) {
@@ -66658,10 +66672,31 @@ var require_execution_proof = __commonJS({
         }),
         verdict_kind: typeof input.verdict?.kind === "string" ? input.verdict.kind : "UNKNOWN",
         execution_result_hash: Object.freeze(executionResultHashOf(input)),
-        limits: LIMITS
+        limits: LIMITS,
+        commit_observation: freezeCommitObservation(input.commitObservation)
       };
+      if (input.monitoringDelivery && typeof input.monitoringDelivery === "object") {
+        proof.monitoring_delivery = freezeMonitoringDelivery(input.monitoringDelivery);
+      }
+      if (input.casEvidence && typeof input.casEvidence === "object") {
+        proof.cas_evidence = Object.freeze({ ...input.casEvidence });
+      }
+      if (Array.isArray(input.recheckTrail) && input.recheckTrail.length > 0) {
+        proof.recheck_trail = Object.freeze(input.recheckTrail.map((e) => Object.freeze({ ...e })));
+      }
       return freezeProof(proof);
     }
+    function freezeMonitoringDelivery(d) {
+      return Object.freeze({
+        status: d.status,
+        ...d.reason ? { reason: d.reason } : {},
+        ...d.evidence ? { evidence: Object.freeze({ ...d.evidence }) } : {}
+      });
+    }
+    function freezeCommitObservation(obs) {
+      const o = obs && typeof obs === "object" ? { ...obs, ...obs.blast ? { blast: Object.freeze({ ...obs.blast }) } : {} } : { status: "not_observed", observed_at: "", host_attestation: "absent" };
+      return Object.freeze(o);
+    }
     function freezeProof(p) {
       return Object.freeze(p);
     }
@@ -67057,20 +67092,2049 @@ var require_conditional_write = __commonJS({
         }
         throw err;
       }
+      let observed_token = null;
+      try {
+        observed_token = await args.current_token();
+      } catch (err) {
+        if (args.detect_stale_during_commit === true)
+          throw err;
+        observed_token = null;
+      }
       if (args.detect_stale_during_commit === true && typeof args.expected_after_commit === "function") {
         const want = await args.expected_after_commit(result);
-        const post = await args.current_token();
-        if (!tokensEqual(want, post)) {
+        if (!tokensEqual(want, observed_token)) {
           return {
             status: "committed_stale_detected",
             reason: "stale_during_commit",
             result,
             expected_token: expected,
-            post_commit_token: post == null ? null : post
+            post_commit_token: observed_token,
+            observed_token
+          };
+        }
+      }
+      return { status: "committed", result, version_token: expected, observed_token };
+    }
+  }
+});
+
+// node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/fs.js
+var require_fs = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/fs.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
+      var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function(o2) {
+          var ar = [];
+          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
+          return ar;
+        };
+        return ownKeys(o);
+      };
+      return function(mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) {
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        }
+        __setModuleDefault(result, mod);
+        return result;
+      };
+    })();
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.tokensEqual = exports2.FS_ABSENT_TOKEN = exports2.FS_VERSION_TOKEN_PREFIX = void 0;
+    exports2.fsTokenContentHash = fsTokenContentHash;
+    exports2.createFsVersionToken = createFsVersionToken;
+    exports2.readVersionedFile = readVersionedFile;
+    exports2.writeFileIfUnchanged = writeFileIfUnchanged;
+    exports2.createFsPriorContentResolver = createFsPriorContentResolver;
+    var node_crypto_1 = require("node:crypto");
+    var node_fs_1 = require("node:fs");
+    var path = __importStar(require("node:path"));
+    var conditional_write_js_1 = require_conditional_write();
+    Object.defineProperty(exports2, "tokensEqual", { enumerable: true, get: function() {
+      return conditional_write_js_1.tokensEqual;
+    } });
+    exports2.FS_VERSION_TOKEN_PREFIX = "fs:v1:";
+    exports2.FS_ABSENT_TOKEN = "fs:v1:absent";
+    function sha256hex(buf) {
+      return (0, node_crypto_1.createHash)("sha256").update(buf).digest("hex");
+    }
+    function fsTokenContentHash(token) {
+      if (typeof token !== "string" || !token.startsWith(exports2.FS_VERSION_TOKEN_PREFIX))
+        return null;
+      if (token === exports2.FS_ABSENT_TOKEN)
+        return null;
+      const rest = token.slice(exports2.FS_VERSION_TOKEN_PREFIX.length);
+      const colon = rest.indexOf(":");
+      if (colon < 0)
+        return null;
+      const hash = rest.slice(colon + 1);
+      return /^[a-f0-9]{64}$/.test(hash) ? hash : null;
+    }
+    async function createFsVersionToken(filePath) {
+      let st;
+      try {
+        st = await node_fs_1.promises.stat(filePath);
+      } catch (err) {
+        const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
+        if (code === "ENOENT")
+          return exports2.FS_ABSENT_TOKEN;
+        throw err;
+      }
+      if (!st.isFile()) {
+        throw new Error(`createFsVersionToken: not a regular file: ${filePath}`);
+      }
+      const buf = await node_fs_1.promises.readFile(filePath);
+      const hash = sha256hex(buf);
+      const mtimeMs = Math.trunc(st.mtimeMs);
+      return `${exports2.FS_VERSION_TOKEN_PREFIX}${mtimeMs}:${hash}`;
+    }
+    async function readVersionedFile(filePath) {
+      const version_token = await createFsVersionToken(filePath);
+      if (version_token === exports2.FS_ABSENT_TOKEN) {
+        return { content: "", version_token };
+      }
+      const content = await node_fs_1.promises.readFile(filePath, "utf8");
+      return { content, version_token };
+    }
+    async function writeFileIfUnchanged(args) {
+      const target = path.resolve(args.path);
+      const body = typeof args.content === "string" ? Buffer.from(args.content, "utf8") : args.content;
+      const writtenHash = sha256hex(body);
+      return (0, conditional_write_js_1.executeIfUnchanged)({
+        expected_token: args.expected_token,
+        current_token: () => createFsVersionToken(target),
+        detect_stale_during_commit: true,
+        // Post-commit: token content-hash must equal sha256 of what we wrote (mtime may vary).
+        expected_after_commit: async (result) => {
+          const post = await createFsVersionToken(target);
+          const postHash = fsTokenContentHash(post);
+          if (postHash === result.written_content_hash)
+            return post;
+          return `${exports2.FS_VERSION_TOKEN_PREFIX}0:stale_during_commit_mismatch`;
+        },
+        write: async () => {
+          const dir = path.dirname(target);
+          await node_fs_1.promises.mkdir(dir, { recursive: true });
+          const tmp = path.join(dir, `.coderifts-cas-${path.basename(target)}-${process.pid}-${(0, node_crypto_1.randomBytes)(6).toString("hex")}.tmp`);
+          try {
+            await node_fs_1.promises.writeFile(tmp, body);
+            const still = await createFsVersionToken(target);
+            if (!(0, conditional_write_js_1.tokensEqual)(args.expected_token, still)) {
+              try {
+                await node_fs_1.promises.unlink(tmp);
+              } catch {
+              }
+              throw new conditional_write_js_1.StaleVersionTokenAbort(still);
+            }
+            await node_fs_1.promises.rename(tmp, target);
+          } catch (err) {
+            if (err instanceof conditional_write_js_1.StaleVersionTokenAbort)
+              throw err;
+            try {
+              await node_fs_1.promises.unlink(tmp);
+            } catch {
+            }
+            throw err;
+          }
+          return { path: target, bytes: body.length, written_content_hash: writtenHash };
+        }
+      });
+    }
+    function createFsPriorContentResolver(options) {
+      const pathForArtifact = options?.pathForArtifact;
+      return async (req) => {
+        let filePath = typeof req.path === "string" && req.path.length > 0 ? req.path : void 0;
+        if (!filePath && pathForArtifact) {
+          const mapped = pathForArtifact(req.artifactId);
+          if (typeof mapped === "string" && mapped.length > 0)
+            filePath = mapped;
+        }
+        if (!filePath)
+          return null;
+        try {
+          return await node_fs_1.promises.readFile(filePath, "utf8");
+        } catch (err) {
+          const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
+          if (code === "ENOENT")
+            return null;
+          throw err;
+        }
+      };
+    }
+  }
+});
+
+// node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/api.js
+var require_api3 = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/api.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.tokensEqual = exports2.API_ABSENT_TOKEN = exports2.API_VERSION_TOKEN_PREFIX = void 0;
+    exports2.createApiVersionToken = createApiVersionToken;
+    exports2.apiTokenRaw = apiTokenRaw;
+    exports2.writeApiIfUnchanged = writeApiIfUnchanged;
+    var conditional_write_js_1 = require_conditional_write();
+    Object.defineProperty(exports2, "tokensEqual", { enumerable: true, get: function() {
+      return conditional_write_js_1.tokensEqual;
+    } });
+    exports2.API_VERSION_TOKEN_PREFIX = "api:v1:";
+    exports2.API_ABSENT_TOKEN = "api:v1:absent";
+    function createApiVersionToken(etag) {
+      if (etag == null)
+        return exports2.API_ABSENT_TOKEN;
+      let s = String(etag).trim();
+      if (s.length === 0)
+        return exports2.API_ABSENT_TOKEN;
+      if (s.startsWith("W/") || s.startsWith("w/"))
+        s = s.slice(2).trim();
+      if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
+        s = s.slice(1, -1);
+      }
+      if (s.length === 0)
+        return exports2.API_ABSENT_TOKEN;
+      return `${exports2.API_VERSION_TOKEN_PREFIX}${s}`;
+    }
+    function apiTokenRaw(token) {
+      if (typeof token !== "string" || !token.startsWith(exports2.API_VERSION_TOKEN_PREFIX))
+        return null;
+      if (token === exports2.API_ABSENT_TOKEN)
+        return null;
+      const raw = token.slice(exports2.API_VERSION_TOKEN_PREFIX.length);
+      return raw.length > 0 ? raw : null;
+    }
+    async function writeApiIfUnchanged(args) {
+      const detect = args.detect_stale_during_commit === true;
+      return (0, conditional_write_js_1.executeIfUnchanged)({
+        expected_token: args.expected_token,
+        current_token: async () => createApiVersionToken(await args.current_etag()),
+        detect_stale_during_commit: detect,
+        expected_after_commit: detect ? async (written) => {
+          if (typeof written.new_etag === "string" && written.new_etag.trim().length > 0) {
+            return createApiVersionToken(written.new_etag);
+          }
+          return createApiVersionToken(await args.current_etag());
+        } : void 0,
+        write: async () => {
+          const report = await args.write({
+            if_match: apiTokenRaw(args.expected_token),
+            expected_token: args.expected_token
+          });
+          if (!report || typeof report !== "object") {
+            throw new Error("writeApiIfUnchanged: host write must return ApiHostWriteReport");
+          }
+          if (report.status === "precondition_failed") {
+            const cur = report.current_etag !== void 0 ? createApiVersionToken(report.current_etag) : null;
+            throw new conditional_write_js_1.StaleVersionTokenAbort(cur);
+          }
+          if (report.status !== "committed") {
+            throw new Error(`writeApiIfUnchanged: unknown host report status ${String(report.status)}`);
+          }
+          const new_etag = report.new_etag === void 0 || report.new_etag === null ? null : String(report.new_etag);
+          return {
+            new_etag,
+            result: report.result
+          };
+        }
+      });
+    }
+  }
+});
+
+// node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/db.js
+var require_db2 = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/db.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.tokensEqual = exports2.DB_ABSENT_TOKEN = exports2.DB_VERSION_TOKEN_PREFIX = void 0;
+    exports2.createDbVersionToken = createDbVersionToken;
+    exports2.dbTokenRaw = dbTokenRaw;
+    exports2.writeDbIfUnchanged = writeDbIfUnchanged;
+    var conditional_write_js_1 = require_conditional_write();
+    Object.defineProperty(exports2, "tokensEqual", { enumerable: true, get: function() {
+      return conditional_write_js_1.tokensEqual;
+    } });
+    exports2.DB_VERSION_TOKEN_PREFIX = "db:v1:";
+    exports2.DB_ABSENT_TOKEN = "db:v1:absent";
+    function createDbVersionToken(version) {
+      if (version == null)
+        return exports2.DB_ABSENT_TOKEN;
+      if (typeof version === "number" && !Number.isFinite(version))
+        return exports2.DB_ABSENT_TOKEN;
+      const s = String(version).trim();
+      if (s.length === 0)
+        return exports2.DB_ABSENT_TOKEN;
+      return `${exports2.DB_VERSION_TOKEN_PREFIX}${s}`;
+    }
+    function dbTokenRaw(token) {
+      if (typeof token !== "string" || !token.startsWith(exports2.DB_VERSION_TOKEN_PREFIX))
+        return null;
+      if (token === exports2.DB_ABSENT_TOKEN)
+        return null;
+      const raw = token.slice(exports2.DB_VERSION_TOKEN_PREFIX.length);
+      return raw.length > 0 ? raw : null;
+    }
+    function normalizeDbReport(report) {
+      if ("rows_affected" in report && typeof report.rows_affected === "number") {
+        const r = report;
+        if (r.rows_affected === 0) {
+          return {
+            kind: "conflict",
+            new_version: void 0,
+            current_version: void 0,
+            rows_affected: 0
           };
         }
+        return {
+          kind: "committed",
+          new_version: r.new_version,
+          result: r.result,
+          rows_affected: r.rows_affected
+        };
+      }
+      if ("status" in report && report.status === "conflict") {
+        const r = report;
+        return {
+          kind: "conflict",
+          new_version: void 0,
+          current_version: r.current_version
+        };
+      }
+      if ("status" in report && report.status === "committed") {
+        const r = report;
+        return {
+          kind: "committed",
+          new_version: r.new_version,
+          result: r.result
+        };
       }
-      return { status: "committed", result, version_token: expected };
+      throw new Error("writeDbIfUnchanged: host write must return DbHostWriteReport");
+    }
+    async function writeDbIfUnchanged(args) {
+      const detect = args.detect_stale_during_commit === true;
+      return (0, conditional_write_js_1.executeIfUnchanged)({
+        expected_token: args.expected_token,
+        current_token: async () => createDbVersionToken(await args.current_version()),
+        detect_stale_during_commit: detect,
+        expected_after_commit: detect ? async (written) => {
+          if (typeof written.new_version === "string" && written.new_version.trim().length > 0) {
+            return createDbVersionToken(written.new_version);
+          }
+          return createDbVersionToken(await args.current_version());
+        } : void 0,
+        write: async () => {
+          const report = await args.write({
+            expected_version: dbTokenRaw(args.expected_token),
+            expected_token: args.expected_token
+          });
+          const norm = normalizeDbReport(report);
+          if (norm.kind === "conflict") {
+            const cur = norm.current_version !== void 0 ? createDbVersionToken(norm.current_version) : null;
+            throw new conditional_write_js_1.StaleVersionTokenAbort(cur);
+          }
+          const new_version = norm.new_version === void 0 || norm.new_version === null ? null : String(norm.new_version);
+          return {
+            new_version,
+            result: norm.result,
+            rows_affected: norm.rows_affected
+          };
+        }
+      });
+    }
+  }
+});
+
+// node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/registry.js
+var require_registry = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/registry.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.tokensEqual = exports2.REGISTRY_ABSENT_TOKEN = exports2.REGISTRY_VERSION_TOKEN_PREFIX = void 0;
+    exports2.createRegistryVersionToken = createRegistryVersionToken;
+    exports2.registryTokenRaw = registryTokenRaw;
+    exports2.writeRegistryIfUnchanged = writeRegistryIfUnchanged;
+    var conditional_write_js_1 = require_conditional_write();
+    Object.defineProperty(exports2, "tokensEqual", { enumerable: true, get: function() {
+      return conditional_write_js_1.tokensEqual;
+    } });
+    exports2.REGISTRY_VERSION_TOKEN_PREFIX = "registry:v1:";
+    exports2.REGISTRY_ABSENT_TOKEN = "registry:v1:absent";
+    function createRegistryVersionToken(token) {
+      if (token == null)
+        return exports2.REGISTRY_ABSENT_TOKEN;
+      if (typeof token === "number" && !Number.isFinite(token))
+        return exports2.REGISTRY_ABSENT_TOKEN;
+      const s = String(token).trim();
+      if (s.length === 0)
+        return exports2.REGISTRY_ABSENT_TOKEN;
+      return `${exports2.REGISTRY_VERSION_TOKEN_PREFIX}${s}`;
+    }
+    function registryTokenRaw(token) {
+      if (typeof token !== "string" || !token.startsWith(exports2.REGISTRY_VERSION_TOKEN_PREFIX)) {
+        return null;
+      }
+      if (token === exports2.REGISTRY_ABSENT_TOKEN)
+        return null;
+      const raw = token.slice(exports2.REGISTRY_VERSION_TOKEN_PREFIX.length);
+      return raw.length > 0 ? raw : null;
+    }
+    function normalizeRegistryReport(report) {
+      if (!report || typeof report !== "object") {
+        throw new Error("writeRegistryIfUnchanged: host compareAndSwap must return RegistryHostCasReport");
+      }
+      if ("swapped" in report) {
+        if (report.swapped === true) {
+          return { kind: "committed", new_token: report.new_token, result: report.result };
+        }
+        return { kind: "conflict", current_token: report.current_token };
+      }
+      if (report.status === "committed") {
+        return { kind: "committed", new_token: report.new_token, result: report.result };
+      }
+      if (report.status === "conflict") {
+        return { kind: "conflict", current_token: report.current_token };
+      }
+      throw new Error("writeRegistryIfUnchanged: unknown host report shape");
+    }
+    async function writeRegistryIfUnchanged(args) {
+      const detect = args.detect_stale_during_commit === true;
+      return (0, conditional_write_js_1.executeIfUnchanged)({
+        expected_token: args.expected_token,
+        current_token: async () => createRegistryVersionToken(await args.current_token()),
+        detect_stale_during_commit: detect,
+        expected_after_commit: detect ? async (written) => {
+          if (typeof written.new_token === "string" && written.new_token.trim().length > 0) {
+            return createRegistryVersionToken(written.new_token);
+          }
+          return createRegistryVersionToken(await args.current_token());
+        } : void 0,
+        write: async () => {
+          const report = await args.compareAndSwap({
+            expected: registryTokenRaw(args.expected_token),
+            expected_token: args.expected_token
+          });
+          const norm = normalizeRegistryReport(report);
+          if (norm.kind === "conflict") {
+            const cur = norm.current_token !== void 0 ? createRegistryVersionToken(norm.current_token) : null;
+            throw new conditional_write_js_1.StaleVersionTokenAbort(cur);
+          }
+          const new_token = norm.new_token === void 0 || norm.new_token === null ? null : String(norm.new_token);
+          return {
+            new_token,
+            result: norm.result
+          };
+        }
+      });
+    }
+  }
+});
+
+// node_modules/@coderifts/agent-guard/dist/cjs/commit-observation.js
+var require_commit_observation = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/commit-observation.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.hashObservedContent = hashObservedContent;
+    exports2.observeCommit = observeCommit;
+    var node_crypto_1 = require("node:crypto");
+    var node_fs_1 = require("node:fs");
+    var fs_js_1 = require_fs();
+    var api_js_1 = require_api3();
+    var db_js_1 = require_db2();
+    var registry_js_1 = require_registry();
+    var conditional_write_js_1 = require_conditional_write();
+    function specStr(v) {
+      if (v == null)
+        return "";
+      return typeof v === "string" ? v : JSON.stringify(v);
+    }
+    function hashObservedContent(v) {
+      return "sha256:" + (0, node_crypto_1.createHash)("sha256").update(specStr(v), "utf8").digest("hex");
+    }
+    function unobserved(now, host = "absent") {
+      return { status: "not_observed", observed_at: now, host_attestation: host };
+    }
+    function casStatus(result) {
+      const s = result && typeof result === "object" ? result.status : null;
+      return s === "committed" || s === "refused" || s === "committed_stale_detected" ? s : null;
+    }
+    function hostLabel(cas, drifted) {
+      if (cas == null)
+        return "absent";
+      if (cas === "refused")
+        return "host_attested_refused";
+      if (cas === "committed" && drifted)
+        return "conflict";
+      if (cas === "committed_stale_detected")
+        return drifted ? "conflict" : "host_attested_committed";
+      return "host_attested_committed";
+    }
+    function casInner(result) {
+      if (!result || typeof result !== "object")
+        return null;
+      const o = result;
+      if (o.status === "committed" || o.status === "committed_stale_detected") {
+        return o.result && typeof o.result === "object" ? o.result : null;
+      }
+      return o;
+    }
+    function inferPath(call, result) {
+      const args = call.arguments && typeof call.arguments === "object" ? call.arguments : {};
+      if (typeof args.path === "string" && args.path)
+        return args.path;
+      if (Array.isArray(call.filesTouched) && typeof call.filesTouched[0] === "string" && call.filesTouched[0]) {
+        return call.filesTouched[0];
+      }
+      const inner = casInner(result);
+      return inner && typeof inner.path === "string" && inner.path ? inner.path : null;
+    }
+    function casObservedToken(result) {
+      if (!result || typeof result !== "object")
+        return null;
+      const o = result;
+      if (typeof o.observed_token === "string" && o.observed_token)
+        return o.observed_token;
+      if (typeof o.post_commit_token === "string" && o.post_commit_token)
+        return o.post_commit_token;
+      return null;
+    }
+    function intendedPostToken(result) {
+      const inner = casInner(result);
+      if (!inner)
+        return null;
+      if (typeof inner.new_etag === "string" && inner.new_etag.trim())
+        return (0, api_js_1.createApiVersionToken)(inner.new_etag);
+      if (inner.new_version != null && String(inner.new_version).trim()) {
+        return (0, db_js_1.createDbVersionToken)(inner.new_version);
+      }
+      if (inner.new_token != null && String(inner.new_token).trim()) {
+        return (0, registry_js_1.createRegistryVersionToken)(inner.new_token);
+      }
+      if (typeof inner.written_content_hash === "string" && /^[a-f0-9]{64}$/.test(inner.written_content_hash)) {
+        return inner.written_content_hash;
+      }
+      return null;
+    }
+    function authorizedAfter(artifacts) {
+      if (!Array.isArray(artifacts))
+        return void 0;
+      for (const a of artifacts) {
+        if (a && a.after !== void 0 && a.after !== null)
+          return a.after;
+      }
+      return void 0;
+    }
+    async function observeCommit(input) {
+      const cas = casStatus(input.result);
+      const host0 = hostLabel(cas, false);
+      if (input.enabled !== true)
+        return unobserved(input.now, "absent");
+      try {
+        return await observeInner(input, cas, host0);
+      } catch {
+        return unobserved(input.now, host0);
+      }
+    }
+    async function observeInner(input, cas, host0) {
+      const now = input.now;
+      const expectedAfter = authorizedAfter(input.call.artifacts);
+      const filePath = inferPath(input.call, input.result);
+      let observedContent = null;
+      let token;
+      if (filePath && expectedAfter !== void 0) {
+        const fsTok = await (0, fs_js_1.createFsVersionToken)(filePath);
+        token = fsTok;
+        observedContent = fsTok === fs_js_1.FS_ABSENT_TOKEN ? "" : await node_fs_1.promises.readFile(filePath, "utf8");
+      }
+      if (observedContent !== null && expectedAfter !== void 0) {
+        const observed_fp = hashObservedContent(observedContent);
+        const expected_fp = hashObservedContent(expectedAfter);
+        const match = observed_fp === expected_fp;
+        const obs = {
+          status: match ? "observed_match" : "observed_drift",
+          observed_fp,
+          expected_fp,
+          token,
+          observed_at: now,
+          host_attestation: hostLabel(cas, !match)
+        };
+        if (!match)
+          obs.blast = await contentBlast(input, observedContent);
+        return obs;
+      }
+      const observedTok = casObservedToken(input.result);
+      const intended = intendedPostToken(input.result);
+      if (observedTok && intended) {
+        const tokenMatch = intended.length === 64 && !intended.includes(":") ? (0, fs_js_1.fsTokenContentHash)(observedTok) === intended : (0, conditional_write_js_1.tokensEqual)(observedTok, intended);
+        const obs = {
+          status: tokenMatch ? "observed_token_match" : "observed_drift",
+          token: observedTok,
+          observed_at: now,
+          host_attestation: hostLabel(cas, !tokenMatch)
+        };
+        if (!tokenMatch) {
+          obs.observed_fp = observedTok;
+          obs.expected_fp = intended;
+          obs.blast = { compared: "token" };
+        }
+        return obs;
+      }
+      if (observedTok)
+        return { status: "not_observed", token: observedTok, observed_at: now, host_attestation: host0 };
+      return unobserved(now, host0);
+    }
+    async function contentBlast(input, observedContent) {
+      const pf = input.preflightOnObserved;
+      if (typeof pf !== "function")
+        return { compared: "content" };
+      const arts = Array.isArray(input.call.artifacts) ? input.call.artifacts.map((a) => ({ ...a, after: observedContent })) : [{ after: observedContent }];
+      try {
+        const r = await pf(arts);
+        if (!r.ok)
+          return { compared: "content", unavailable: true, cause: r.cause };
+        const raw = r.response;
+        const env = raw && typeof raw === "object" && raw.decision_result && typeof raw.decision_result === "object" ? raw.decision_result : raw && typeof raw === "object" ? raw : null;
+        if (!env)
+          return { compared: "content", unavailable: true };
+        return {
+          compared: "content",
+          decision: typeof env.decision === "string" ? env.decision : void 0,
+          execution_action: typeof env.execution_action === "string" ? env.execution_action : void 0,
+          decision_id: typeof env.decision_id === "string" ? env.decision_id : null
+        };
+      } catch (err) {
+        return { compared: "content", unavailable: true, cause: err instanceof Error ? err.message : "preflight_threw" };
+      }
+    }
+  }
+});
+
+// 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. Requires top-level `preflight_mode: 'analyze' | 'authorize'` (Decision Spec v2;
+       * server returns HTTP 400 if omitted). Prefer `analyzeChangeSet` / `authorizeChangeSet` so the
+       * two authorization meanings cannot be mixed. POST /api/v1/preflight.
+       *
+       * Returns the mode-discriminated union: narrow on `preflight_mode` before reading
+       * `decision` / `safe_for_agent` (authorize) or `analysis_outcome` (analyze). Call
+       * `analyzeChangeSet` / `authorizeChangeSet` instead to get an already-narrowed type.
+       */
+      async preflightChangeSet(req) {
+        return this.request("POST", "/api/v1/preflight", req);
+      }
+      /**
+       * Risk-only preflight (`preflight_mode: 'analyze'`). Informational — not permission;
+       * does not mint an operation-bound receipt. POST /api/v1/preflight.
+       *
+       * The mode is fixed by this method, so the analyze branch is returned directly — there is no
+       * `decision` / `execution_action` / `safe_for_agent` on it, by protocol.
+       */
+      async analyzeChangeSet(req) {
+        return this.preflightChangeSet({
+          ...req,
+          preflight_mode: "analyze"
+        });
+      }
+      /**
+       * Operation-bound authorize preflight (`preflight_mode: 'authorize'`).
+       * Requires a non-empty `context.operation` (e.g. merge | deploy | tool_call) — the server
+       * returns HTTP 400 otherwise. May mint a signed receipt. POST /api/v1/preflight.
+       *
+       * The mode is fixed by this method, so the authorize branch is returned directly:
+       * `decision`, `execution_action` and `safe_for_agent` are present without narrowing.
+       */
+      async authorizeChangeSet(req) {
+        return this.preflightChangeSet({
+          ...req,
+          preflight_mode: "authorize"
+        });
+      }
+      // ─── 9. verifyReceipt ──────────────────────────────────────────────────
+      /**
+       * Verify a CodeRifts chain receipt. 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.
+       *
+       * Two questions, and which one you get depends on whether you pass `intended`:
+       *
+       * - `verifyReceipt(token)` — SIGNATURE only. `valid` / `status` answer authenticity and expiry
+       *   (30s clock-skew leeway on expiry; 0s for destructive operations in production when the
+       *   intended context declares them). `currently_authorized` comes back **null**, meaning not
+       *   evaluated. Null is not a pass.
+       * - `verifyReceipt(token, { operation, environment, decision_result, … })` — AUTHORIZATION.
+       *   The server binds the receipt against the stated intent and `currently_authorized` becomes a
+       *   real `true` / `false`, with `authz_status` / `authz_reason` explaining a `false`.
+       *
+       * A valid signature is not authorization: only the second form can answer "does this receipt
+       * authorize the action I am about to take?". Supply the context you are about to act under.
+       *
+       * @param token     the chain-receipt token
+       * @param intended  optional intended context; any subset of its fields may be supplied
+       */
+      async verifyReceipt(token, intended) {
+        const body = { token };
+        if (intended && typeof intended === "object") {
+          for (const [key, value] of Object.entries(intended)) {
+            if (value !== void 0)
+              body[key] = value;
+          }
+        }
+        return this.request("POST", "/api/v1/verify-receipt", body);
+      }
+      // ─── 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/leeway.js
+var require_leeway = __commonJS({
+  "node_modules/@coderifts/sdk/dist/cjs/leeway.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CLOCK_SKEW_LEEWAY_MS = void 0;
+    exports2.declaresDestructiveProduction = declaresDestructiveProduction;
+    exports2.expiryLeewayMs = expiryLeewayMs;
+    exports2.isReceiptExpired = isReceiptExpired;
+    exports2.isIssuedInFuture = isIssuedInFuture;
+    exports2.CLOCK_SKEW_LEEWAY_MS = 3e4;
+    function declaresDestructiveProduction(context) {
+      if (!context || typeof context !== "object")
+        return false;
+      if (context.environment !== "production")
+        return false;
+      return false;
+    }
+    function expiryLeewayMs(context) {
+      if (declaresDestructiveProduction(context))
+        return 0;
+      return exports2.CLOCK_SKEW_LEEWAY_MS;
+    }
+    function isReceiptExpired(expiresAtMs, nowMs, context) {
+      if (!Number.isFinite(expiresAtMs) || !Number.isFinite(nowMs))
+        return false;
+      return expiresAtMs + expiryLeewayMs(context) < nowMs;
+    }
+    function isIssuedInFuture(issuedAtMs, nowMs, context) {
+      if (!Number.isFinite(issuedAtMs) || !Number.isFinite(nowMs))
+        return false;
+      return issuedAtMs > nowMs + expiryLeewayMs(context);
+    }
+  }
+});
+
+// node_modules/@coderifts/sdk/dist/cjs/execution-grant.js
+var require_execution_grant = __commonJS({
+  "node_modules/@coderifts/sdk/dist/cjs/execution-grant.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CLOCK_SKEW_LEEWAY_MS = exports2.GRANT_SIGNING_PREFIX = exports2.GRANT_VERSION = void 0;
+    exports2.afterPayloadCanonical = afterPayloadCanonical;
+    exports2.computeScopeHash = computeScopeHash;
+    exports2.receiptDigest = receiptDigest;
+    exports2.verifyExecutionGrant = verifyExecutionGrant;
+    var crypto_1 = require("crypto");
+    var leeway_js_1 = require_leeway();
+    Object.defineProperty(exports2, "CLOCK_SKEW_LEEWAY_MS", { enumerable: true, get: function() {
+      return leeway_js_1.CLOCK_SKEW_LEEWAY_MS;
+    } });
+    exports2.GRANT_VERSION = "cr.exec.v1";
+    exports2.GRANT_SIGNING_PREFIX = "crexec.v1";
+    var NUL = "";
+    var SIGNED_FIELDS = [
+      "kid",
+      "receipt_digest",
+      "scope_hash",
+      "audience",
+      "operation",
+      "target_id",
+      "jti",
+      "iat",
+      "exp"
+    ];
+    function sha256hex(str) {
+      return (0, crypto_1.createHash)("sha256").update(String(str), "utf8").digest("hex");
+    }
+    function specStr(v) {
+      if (v == null)
+        return "";
+      return typeof v === "string" ? v : JSON.stringify(v);
+    }
+    function afterPayloadCanonical(artifacts) {
+      const list = Array.isArray(artifacts) ? artifacts.slice() : [];
+      list.sort((x, y) => {
+        const kx = `${x?.type ?? ""}${NUL}${x?.id ?? ""}`;
+        const ky = `${y?.type ?? ""}${NUL}${y?.id ?? ""}`;
+        return kx < ky ? -1 : kx > ky ? 1 : 0;
+      });
+      return list.map((a) => specStr(a && a.after)).join(NUL);
+    }
+    function computeScopeHash(args) {
+      const preimage = [
+        args.operation == null ? "" : String(args.operation),
+        args.target_id == null ? "" : String(args.target_id),
+        args.after_payload == null ? "" : String(args.after_payload)
+      ].join(NUL);
+      return `sha256:${sha256hex(preimage)}`;
+    }
+    function receiptDigest(token) {
+      return `sha256:${sha256hex(String(token))}`;
+    }
+    function scalar(v) {
+      return v == null ? "" : String(v);
+    }
+    function hasStateNonce(body) {
+      return typeof body.state_nonce === "string" && body.state_nonce.length > 0;
+    }
+    function signingInput(body) {
+      const parts = [
+        exports2.GRANT_SIGNING_PREFIX,
+        scalar(body.kid),
+        scalar(body.receipt_digest),
+        scalar(body.scope_hash),
+        scalar(body.audience),
+        scalar(body.operation),
+        scalar(body.target_id),
+        scalar(body.jti),
+        scalar(body.iat),
+        scalar(body.exp)
+      ];
+      if (hasStateNonce(body))
+        parts.push(scalar(body.state_nonce));
+      return parts.join("|");
+    }
+    function verifyExecutionGrant(token, opts = {}) {
+      if (typeof token !== "string" || token.length === 0) {
+        return { valid: false, status: "MALFORMED", reason: "malformed_structure" };
+      }
+      const segments = token.split(".");
+      if (segments.length !== 2 || segments.some((s) => !s)) {
+        return { valid: false, status: "MALFORMED", reason: "malformed_structure" };
+      }
+      let payload;
+      try {
+        payload = JSON.parse(Buffer.from(segments[0], "base64url").toString("utf8"));
+      } catch {
+        return { valid: false, status: "MALFORMED", reason: "bad_json" };
+      }
+      if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return { valid: false, status: "MALFORMED", reason: "bad_json", payload };
+      }
+      if (payload.v !== exports2.GRANT_VERSION) {
+        return { valid: false, status: "MALFORMED", reason: "unsupported_version", payload };
+      }
+      for (const k of SIGNED_FIELDS) {
+        if (typeof payload[k] !== "string") {
+          return { valid: false, status: "MALFORMED", reason: "missing_field", payload };
+        }
+      }
+      if (payload.state_nonce != null && typeof payload.state_nonce !== "string") {
+        return { valid: false, status: "MALFORMED", reason: "bad_state_nonce", payload };
+      }
+      const allowed = /* @__PURE__ */ new Set(["v", ...SIGNED_FIELDS, "state_nonce"]);
+      for (const k of Object.keys(payload)) {
+        if (!allowed.has(k)) {
+          return { valid: false, status: "MALFORMED", reason: "unknown_field", payload };
+        }
+      }
+      for (const k of SIGNED_FIELDS) {
+        if (payload[k].includes("|")) {
+          return { valid: false, status: "INVALID_SIGNATURE", reason: "delimiter_in_field", payload };
+        }
+      }
+      if (hasStateNonce(payload) && payload.state_nonce.includes("|")) {
+        return { valid: false, status: "INVALID_SIGNATURE", reason: "delimiter_in_field", payload };
+      }
+      if (!opts.publicKeyPem) {
+        return { valid: false, status: "UNKNOWN_KEY", reason: "unknown_kid", payload };
+      }
+      let ok = false;
+      try {
+        const key = (0, crypto_1.createPublicKey)(opts.publicKeyPem);
+        ok = (0, crypto_1.verify)(null, Buffer.from(signingInput(payload), "utf8"), key, Buffer.from(segments[1], "base64url"));
+      } catch {
+        return { valid: false, status: "INVALID_SIGNATURE", reason: "signature_error", payload };
+      }
+      if (!ok) {
+        return { valid: false, status: "INVALID_SIGNATURE", reason: "signature_mismatch", payload };
+      }
+      const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+      const expMs = Date.parse(payload.exp);
+      const iatMs = Date.parse(payload.iat);
+      if (!Number.isFinite(expMs) || !Number.isFinite(iatMs)) {
+        return { valid: false, status: "MALFORMED", reason: "bad_timestamp", payload };
+      }
+      if ((0, leeway_js_1.isReceiptExpired)(expMs, now, opts.intended)) {
+        return { valid: false, status: "GRANT_EXPIRED", reason: "expired", payload };
+      }
+      if ((0, leeway_js_1.isIssuedInFuture)(iatMs, now, opts.intended)) {
+        return { valid: false, status: "GRANT_EXPIRED", reason: "iat_in_future", payload };
+      }
+      if (!payload.receipt_digest || !payload.receipt_digest.startsWith("sha256:")) {
+        return { valid: false, status: "GRANT_UNBOUND", reason: "missing_receipt_digest", payload };
+      }
+      const intended = opts.intended || {};
+      if (intended.receipt_token) {
+        if (receiptDigest(intended.receipt_token) !== payload.receipt_digest) {
+          return { valid: false, status: "GRANT_UNBOUND", reason: "receipt_digest_mismatch", payload };
+        }
+      }
+      if (intended.audience != null && intended.audience !== "" && payload.audience !== String(intended.audience)) {
+        return { valid: false, status: "GRANT_WRONG_AUDIENCE", reason: "audience_mismatch", payload };
+      }
+      if (intended.operation != null && intended.operation !== "" && payload.operation !== String(intended.operation)) {
+        return { valid: false, status: "GRANT_SCOPE_MISMATCH", reason: "operation_mismatch", payload };
+      }
+      if (intended.target_id != null && intended.target_id !== "" && payload.target_id !== String(intended.target_id)) {
+        return { valid: false, status: "GRANT_SCOPE_MISMATCH", reason: "target_mismatch", payload };
+      }
+      let expectedScope = null;
+      if (intended.scope_hash)
+        expectedScope = String(intended.scope_hash);
+      else if (intended.after_payload != null) {
+        expectedScope = computeScopeHash({
+          operation: intended.operation != null ? intended.operation : payload.operation,
+          target_id: intended.target_id != null ? intended.target_id : payload.target_id,
+          after_payload: intended.after_payload
+        });
+      }
+      if (expectedScope != null && expectedScope !== payload.scope_hash) {
+        return { valid: false, status: "GRANT_SCOPE_MISMATCH", reason: "scope_hash_mismatch", payload };
+      }
+      return { valid: true, status: "GRANT_CURRENT", reason: null, payload };
+    }
+  }
+});
+
+// node_modules/@coderifts/sdk/dist/cjs/execution-attestation.js
+var require_execution_attestation = __commonJS({
+  "node_modules/@coderifts/sdk/dist/cjs/execution-attestation.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CLOCK_SKEW_LEEWAY_MS = exports2.ATTEST_ENVELOPE_TAG = exports2.ATTEST_SIGNING_PREFIX = exports2.ATTEST_VERSION = void 0;
+    exports2.attestSigningInput = attestSigningInput;
+    exports2.verifyExecutionAttestation = verifyExecutionAttestation;
+    var crypto_1 = require("crypto");
+    var leeway_js_1 = require_leeway();
+    Object.defineProperty(exports2, "CLOCK_SKEW_LEEWAY_MS", { enumerable: true, get: function() {
+      return leeway_js_1.CLOCK_SKEW_LEEWAY_MS;
+    } });
+    exports2.ATTEST_VERSION = "cr.exec.attest.v1";
+    exports2.ATTEST_SIGNING_PREFIX = "crexecattest.v1";
+    exports2.ATTEST_ENVELOPE_TAG = "cr.exec.attest.v1";
+    var REQUIRED_FIELDS = [
+      "executor_kid",
+      "grant_jti",
+      "receipt_digest",
+      "scope_hash",
+      "committed_at"
+    ];
+    function scalar(v) {
+      return v == null ? "" : String(v);
+    }
+    function canonicalMeta(meta) {
+      const keys = Object.keys(meta).sort();
+      const o = {};
+      for (const k of keys)
+        o[k] = meta[k];
+      return JSON.stringify(o);
+    }
+    function metaOk(meta) {
+      if (meta == null)
+        return true;
+      if (typeof meta !== "object" || Array.isArray(meta))
+        return false;
+      const obj = meta;
+      const keys = Object.keys(obj);
+      if (keys.length > 8)
+        return false;
+      for (const k of keys) {
+        if (k.length === 0 || k.length > 64 || k.includes("|"))
+          return false;
+        const v = obj[k];
+        const t = typeof v;
+        if (t !== "string" && t !== "number" && t !== "boolean")
+          return false;
+        if (t === "string" && (v.length > 256 || v.includes("|")))
+          return false;
+      }
+      return true;
+    }
+    function attestSigningInput(body) {
+      const parts = [
+        exports2.ATTEST_SIGNING_PREFIX,
+        scalar(body.executor_kid),
+        scalar(body.grant_jti),
+        scalar(body.receipt_digest),
+        scalar(body.scope_hash),
+        body.state_nonce != null && String(body.state_nonce).length > 0 ? String(body.state_nonce) : "",
+        scalar(body.committed_at),
+        body.result_digest != null && String(body.result_digest).length > 0 ? String(body.result_digest) : ""
+      ];
+      if (body.meta && typeof body.meta === "object") {
+        parts.push(canonicalMeta(body.meta));
+      }
+      return parts.join("|");
+    }
+    function isIssueTimeWithinKeyWindow(ts, keyMeta) {
+      if (!keyMeta || keyMeta.status === "active")
+        return true;
+      if (keyMeta.status !== "retired")
+        return false;
+      if (typeof keyMeta.retired_at !== "string" || keyMeta.retired_at.length === 0)
+        return false;
+      if (typeof ts !== "string" || ts.length === 0)
+        return false;
+      const issueMs = Date.parse(ts);
+      if (!Number.isFinite(issueMs))
+        return false;
+      if (keyMeta.valid_from) {
+        const fromMs = Date.parse(keyMeta.valid_from);
+        if (Number.isFinite(fromMs) && issueMs < fromMs)
+          return false;
+      }
+      const retiredMs = Date.parse(keyMeta.retired_at);
+      if (!Number.isFinite(retiredMs))
+        return false;
+      if (issueMs >= retiredMs)
+        return false;
+      return true;
+    }
+    function resolveExecutorKey(registry, kid) {
+      if (!registry || !Array.isArray(registry.keys) || !kid)
+        return null;
+      const matches = registry.keys.filter((k) => k && k.kid === kid && typeof k.public_key_pem === "string");
+      if (matches.length === 0)
+        return null;
+      const entry = matches.find((k) => k.status === "active") || matches[0];
+      try {
+        return {
+          publicKey: (0, crypto_1.createPublicKey)(entry.public_key_pem),
+          status: entry.status === "retired" ? "retired" : "active",
+          valid_from: entry.valid_from || null,
+          retired_at: entry.retired_at || null
+        };
+      } catch {
+        return null;
+      }
+    }
+    function parseGrantFields(token) {
+      if (typeof token !== "string" || !token)
+        return null;
+      const segments = token.split(".");
+      if (segments.length !== 2 || segments.some((s) => !s))
+        return { unparseable: true };
+      try {
+        const payload = JSON.parse(Buffer.from(segments[0], "base64url").toString("utf8"));
+        if (!payload || typeof payload !== "object")
+          return { unparseable: true };
+        return payload;
+      } catch {
+        return { unparseable: true };
+      }
+    }
+    function nonceOf(obj) {
+      if (!obj)
+        return "";
+      return typeof obj.state_nonce === "string" && obj.state_nonce.length > 0 ? obj.state_nonce : "";
+    }
+    function verifyExecutionAttestation(token, opts) {
+      const fail = (status, reason, payload2) => ({ valid: false, status, reason, payload: payload2 });
+      if (typeof token !== "string" || token.length === 0) {
+        return fail("ATTEST_MALFORMED", "malformed_structure");
+      }
+      const segments = token.split("|");
+      if (segments.length !== 4 || segments.some((s) => !s)) {
+        return fail("ATTEST_MALFORMED", "malformed_structure");
+      }
+      if (segments[0] !== exports2.ATTEST_ENVELOPE_TAG) {
+        return fail("ATTEST_MALFORMED", "unsupported_version");
+      }
+      let payload;
+      try {
+        payload = JSON.parse(Buffer.from(segments[2], "base64url").toString("utf8"));
+      } catch {
+        return fail("ATTEST_MALFORMED", "bad_json");
+      }
+      if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return fail("ATTEST_MALFORMED", "bad_json");
+      }
+      if (payload.v !== exports2.ATTEST_VERSION) {
+        return fail("ATTEST_MALFORMED", "unsupported_version", payload);
+      }
+      for (const k of REQUIRED_FIELDS) {
+        if (typeof payload[k] !== "string" || !payload[k].length) {
+          return fail("ATTEST_MALFORMED", "missing_field", payload);
+        }
+      }
+      if (payload.executor_kid !== segments[1]) {
+        return fail("ATTEST_MALFORMED", "kid_mismatch", payload);
+      }
+      const allowed = /* @__PURE__ */ new Set(["v", ...REQUIRED_FIELDS, "state_nonce", "result_digest", "meta"]);
+      for (const k of Object.keys(payload)) {
+        if (!allowed.has(k))
+          return fail("ATTEST_MALFORMED", "unknown_field", payload);
+      }
+      if (!metaOk(payload.meta))
+        return fail("ATTEST_MALFORMED", "meta_bounds", payload);
+      for (const k of [...REQUIRED_FIELDS, "state_nonce", "result_digest"]) {
+        if (typeof payload[k] === "string" && payload[k].includes("|")) {
+          return fail("ATTEST_INVALID_SIGNATURE", "delimiter_in_field", payload);
+        }
+      }
+      const resolved = resolveExecutorKey(opts.registry, String(payload.executor_kid));
+      if (!resolved)
+        return fail("ATTEST_UNKNOWN_KEY", "unknown_kid", payload);
+      let sigOk = false;
+      try {
+        sigOk = (0, crypto_1.verify)(null, Buffer.from(attestSigningInput(payload), "utf8"), resolved.publicKey, Buffer.from(segments[3], "base64url"));
+      } catch {
+        return fail("ATTEST_INVALID_SIGNATURE", "signature_error", payload);
+      }
+      if (!sigOk)
+        return fail("ATTEST_INVALID_SIGNATURE", "signature_mismatch", payload);
+      const now = Number.isFinite(opts.now) ? opts.now : Date.now();
+      const committedMs = Date.parse(String(payload.committed_at));
+      if (!Number.isFinite(committedMs))
+        return fail("ATTEST_MALFORMED", "bad_timestamp", payload);
+      if ((0, leeway_js_1.isIssuedInFuture)(committedMs, now, opts.intended)) {
+        return fail("ATTEST_MALFORMED", "committed_at_in_future", payload);
+      }
+      let retiredHistorical = false;
+      if (resolved.status === "retired") {
+        if (!isIssueTimeWithinKeyWindow(String(payload.committed_at), resolved)) {
+          return fail("ATTEST_UNKNOWN_KEY", "retired_key_outside_window", payload);
+        }
+        retiredHistorical = true;
+      }
+      const intended = opts.intended;
+      const wantsCross = !!(intended && (intended.grant || intended.grant_fields || intended.receipt_digest));
+      if (wantsCross && intended) {
+        let gf = null;
+        if (intended.grant_fields)
+          gf = intended.grant_fields;
+        else if (intended.grant)
+          gf = parseGrantFields(intended.grant);
+        if (gf && "unparseable" in gf && gf.unparseable) {
+          return fail("ATTEST_UNBOUND", "grant_unparseable", payload);
+        }
+        if (gf && !("unparseable" in gf)) {
+          if (String(gf.jti || "") !== payload.grant_jti) {
+            return fail("ATTEST_UNBOUND", "grant_jti_mismatch", payload);
+          }
+          if (String(gf.scope_hash || "") !== payload.scope_hash) {
+            return fail("ATTEST_UNBOUND", "scope_hash_mismatch", payload);
+          }
+          if (nonceOf(gf) !== nonceOf(payload)) {
+            return fail("ATTEST_UNBOUND", "state_nonce_mismatch", payload);
+          }
+          if (gf.receipt_digest && gf.receipt_digest !== payload.receipt_digest) {
+            return fail("ATTEST_UNBOUND", "receipt_digest_mismatch", payload);
+          }
+        }
+        if (intended.receipt_digest && intended.receipt_digest !== payload.receipt_digest) {
+          return fail("ATTEST_UNBOUND", "receipt_digest_mismatch", payload);
+        }
+      }
+      if (retiredHistorical) {
+        return { valid: true, status: "ATTEST_RETIRED_KEY_VALID_AT_ISSUE", reason: null, payload };
+      }
+      return { valid: true, status: "ATTEST_VALID", reason: null, payload };
+    }
+  }
+});
+
+// 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.ATTEST_ENVELOPE_TAG = exports2.ATTEST_SIGNING_PREFIX = exports2.ATTEST_VERSION = exports2.attestSigningInput = exports2.verifyExecutionAttestation = exports2.GRANT_SIGNING_PREFIX = exports2.GRANT_VERSION = exports2.receiptDigest = exports2.afterPayloadCanonical = exports2.computeScopeHash = exports2.verifyExecutionGrant = exports2.isIssuedInFuture = exports2.isReceiptExpired = exports2.declaresDestructiveProduction = exports2.expiryLeewayMs = exports2.CLOCK_SKEW_LEEWAY_MS = 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;
+    } });
+    var leeway_js_1 = require_leeway();
+    Object.defineProperty(exports2, "CLOCK_SKEW_LEEWAY_MS", { enumerable: true, get: function() {
+      return leeway_js_1.CLOCK_SKEW_LEEWAY_MS;
+    } });
+    Object.defineProperty(exports2, "expiryLeewayMs", { enumerable: true, get: function() {
+      return leeway_js_1.expiryLeewayMs;
+    } });
+    Object.defineProperty(exports2, "declaresDestructiveProduction", { enumerable: true, get: function() {
+      return leeway_js_1.declaresDestructiveProduction;
+    } });
+    Object.defineProperty(exports2, "isReceiptExpired", { enumerable: true, get: function() {
+      return leeway_js_1.isReceiptExpired;
+    } });
+    Object.defineProperty(exports2, "isIssuedInFuture", { enumerable: true, get: function() {
+      return leeway_js_1.isIssuedInFuture;
+    } });
+    var execution_grant_js_1 = require_execution_grant();
+    Object.defineProperty(exports2, "verifyExecutionGrant", { enumerable: true, get: function() {
+      return execution_grant_js_1.verifyExecutionGrant;
+    } });
+    Object.defineProperty(exports2, "computeScopeHash", { enumerable: true, get: function() {
+      return execution_grant_js_1.computeScopeHash;
+    } });
+    Object.defineProperty(exports2, "afterPayloadCanonical", { enumerable: true, get: function() {
+      return execution_grant_js_1.afterPayloadCanonical;
+    } });
+    Object.defineProperty(exports2, "receiptDigest", { enumerable: true, get: function() {
+      return execution_grant_js_1.receiptDigest;
+    } });
+    Object.defineProperty(exports2, "GRANT_VERSION", { enumerable: true, get: function() {
+      return execution_grant_js_1.GRANT_VERSION;
+    } });
+    Object.defineProperty(exports2, "GRANT_SIGNING_PREFIX", { enumerable: true, get: function() {
+      return execution_grant_js_1.GRANT_SIGNING_PREFIX;
+    } });
+    var execution_attestation_js_1 = require_execution_attestation();
+    Object.defineProperty(exports2, "verifyExecutionAttestation", { enumerable: true, get: function() {
+      return execution_attestation_js_1.verifyExecutionAttestation;
+    } });
+    Object.defineProperty(exports2, "attestSigningInput", { enumerable: true, get: function() {
+      return execution_attestation_js_1.attestSigningInput;
+    } });
+    Object.defineProperty(exports2, "ATTEST_VERSION", { enumerable: true, get: function() {
+      return execution_attestation_js_1.ATTEST_VERSION;
+    } });
+    Object.defineProperty(exports2, "ATTEST_SIGNING_PREFIX", { enumerable: true, get: function() {
+      return execution_attestation_js_1.ATTEST_SIGNING_PREFIX;
+    } });
+    Object.defineProperty(exports2, "ATTEST_ENVELOPE_TAG", { enumerable: true, get: function() {
+      return execution_attestation_js_1.ATTEST_ENVELOPE_TAG;
+    } });
+  }
+});
+
+// node_modules/@coderifts/agent-guard/dist/cjs/cas-attestation.js
+var require_cas_attestation = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/cas-attestation.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CAS_ATTESTATION_SPEC = void 0;
+    exports2.extractExecutorAttestationToken = extractExecutorAttestationToken;
+    exports2.evaluateCasEvidence = evaluateCasEvidence;
+    exports2.isGuardExecutionProof = isGuardExecutionProof;
+    exports2.isExecuteIfUnchangedOutcome = isExecuteIfUnchangedOutcome;
+    exports2.buildCasAttestation = buildCasAttestation;
+    var sdk_1 = require_cjs3();
+    var execution_proof_js_1 = require_execution_proof();
+    exports2.CAS_ATTESTATION_SPEC = "cas-attestation.v1";
+    var LIMITS = Object.freeze({
+      does_not_claim_only_write_on_host: true,
+      does_not_claim_version_token_proves_change_fp_match: true,
+      does_not_claim_committed_stale_is_safe: true,
+      does_not_claim_execution_result_hash_equals_cas_bytes: true,
+      does_not_claim_host_cannot_bypass: true,
+      does_not_claim_governance_redecision: true
+    });
+    var ABSENT_EVIDENCE = Object.freeze({
+      class: "absent",
+      attest_status: null,
+      executor_kid: null,
+      grant_jti: null
+    });
+    function hostClaimed(status, kid, jti) {
+      return Object.freeze({
+        class: "host_claimed",
+        attest_status: status,
+        executor_kid: kid,
+        grant_jti: jti
+      });
+    }
+    function extractExecutorAttestationToken(outcome) {
+      if (!outcome || typeof outcome !== "object")
+        return null;
+      const o = outcome;
+      if (typeof o.executor_attestation === "string" && o.executor_attestation.length > 0) {
+        return o.executor_attestation;
+      }
+      const r = o.result;
+      if (r && typeof r === "object") {
+        const tok = r.executor_attestation;
+        if (typeof tok === "string" && tok.length > 0)
+          return tok;
+      }
+      return null;
+    }
+    function intendedFromOutcome(outcome) {
+      const intended = {};
+      if (!outcome || typeof outcome !== "object")
+        return intended;
+      const o = outcome;
+      const r = o.result && typeof o.result === "object" ? o.result : o;
+      if (typeof r.grant === "string" && r.grant.length > 0)
+        intended.grant = r.grant;
+      else if (typeof r.execution_grant === "string" && r.execution_grant.length > 0) {
+        intended.grant = r.execution_grant;
+      }
+      if (typeof r.receipt_digest === "string" && r.receipt_digest.length > 0) {
+        intended.receipt_digest = r.receipt_digest;
+      }
+      return intended;
+    }
+    function evaluateCasEvidence(outcome, opts = {}) {
+      if (!isExecuteIfUnchangedOutcome(outcome))
+        return ABSENT_EVIDENCE;
+      if (outcome.status === "refused")
+        return ABSENT_EVIDENCE;
+      const token = extractExecutorAttestationToken(outcome);
+      const registry = opts.registry;
+      const fromOutcome = intendedFromOutcome(outcome);
+      const grant = opts.grant || fromOutcome.grant || null;
+      const receipt_digest = opts.receipt_digest || fromOutcome.receipt_digest || null;
+      if (!registry || !Array.isArray(registry.keys)) {
+        return hostClaimed(null, null, null);
+      }
+      if (!token) {
+        return hostClaimed(null, null, null);
+      }
+      const intended = {};
+      if (grant)
+        intended.grant = grant;
+      if (receipt_digest)
+        intended.receipt_digest = receipt_digest;
+      const wantsIntended = Object.keys(intended).length > 0;
+      let verified;
+      try {
+        verified = (0, sdk_1.verifyExecutionAttestation)(token, {
+          registry,
+          ...wantsIntended ? { intended } : {}
+        });
+      } catch {
+        return hostClaimed("ATTEST_MALFORMED", null, null);
+      }
+      const payload = verified.payload && typeof verified.payload === "object" ? verified.payload : null;
+      const kid = payload && typeof payload.executor_kid === "string" ? payload.executor_kid : null;
+      const jti = payload && typeof payload.grant_jti === "string" ? payload.grant_jti : null;
+      if (verified.valid === true && (verified.status === "ATTEST_VALID" || verified.status === "ATTEST_RETIRED_KEY_VALID_AT_ISSUE")) {
+        return Object.freeze({
+          class: "executor_attested",
+          attest_status: verified.status,
+          executor_kid: kid,
+          grant_jti: jti
+        });
+      }
+      return hostClaimed(verified.status, kid, jti);
+    }
+    function isGuardExecutionProof(x) {
+      if (!x || typeof x !== "object")
+        return false;
+      const p = x;
+      return p.proof_spec === execution_proof_js_1.EXECUTION_PROOF_SPEC && p.receipt != null && typeof p.receipt === "object" && p.execution_result_hash != null && typeof p.execution_result_hash === "object";
+    }
+    function isExecuteIfUnchangedOutcome(x) {
+      if (!x || typeof x !== "object")
+        return false;
+      const o = x;
+      if (o.status === "committed") {
+        const c = x;
+        return typeof c.version_token === "string";
+      }
+      if (o.status === "refused") {
+        const r = x;
+        return r.reason === "stale_version_token" && typeof r.expected_token === "string";
+      }
+      if (o.status === "committed_stale_detected") {
+        const s = x;
+        return s.reason === "stale_during_commit" && typeof s.expected_token === "string";
+      }
+      return false;
+    }
+    function freezeExecutionResultHash(h) {
+      return Object.freeze({ ...h });
+    }
+    function projectCas(outcome) {
+      if (outcome.status === "committed") {
+        return Object.freeze({
+          status: "committed",
+          write_ran: true,
+          version_token: outcome.version_token
+        });
+      }
+      if (outcome.status === "refused") {
+        return Object.freeze({
+          status: "refused",
+          write_ran: false,
+          reason: "stale_version_token",
+          expected_token: outcome.expected_token,
+          current_token: outcome.current_token == null ? null : outcome.current_token
+        });
+      }
+      return Object.freeze({
+        status: "committed_stale_detected",
+        write_ran: true,
+        reason: "stale_during_commit",
+        expected_token: outcome.expected_token,
+        post_commit_token: outcome.post_commit_token == null ? null : outcome.post_commit_token
+      });
+    }
+    function buildCasAttestation(proof, outcome, opts = {}) {
+      if (!isGuardExecutionProof(proof)) {
+        throw new TypeError("@coderifts/agent-guard: buildCasAttestation requires a valid guard-execution-proof.v1 object (proof_spec mismatch or missing required fields)");
+      }
+      if (!isExecuteIfUnchangedOutcome(outcome)) {
+        throw new TypeError("@coderifts/agent-guard: buildCasAttestation requires a valid ExecuteIfUnchangedOutcome (status committed | refused | committed_stale_detected with branch fields)");
+      }
+      const receipt_verified = proof.receipt.verified === true;
+      const cas = projectCas(outcome);
+      const write_ran = cas.write_ran === true;
+      const stale_during_commit = cas.status === "committed_stale_detected";
+      const refused = cas.status === "refused";
+      const authorized_and_committed = receipt_verified && cas.status === "committed";
+      const attestation = {
+        attestation_spec: exports2.CAS_ATTESTATION_SPEC,
+        references: Object.freeze({
+          decision_id: proof.decision_id,
+          change_fp: proof.binds_to != null ? proof.binds_to.change_fp : null,
+          operation: proof.binds_to != null ? proof.binds_to.operation : null,
+          execution_result_hash: freezeExecutionResultHash(proof.execution_result_hash),
+          receipt_verified
+        }),
+        cas,
+        derived: Object.freeze({
+          authorized_and_committed,
+          write_ran,
+          stale_during_commit,
+          refused
+        }),
+        cas_evidence: evaluateCasEvidence(outcome, opts),
+        limits: LIMITS
+      };
+      return freezeAttestation(attestation);
+    }
+    function freezeAttestation(a) {
+      return Object.freeze(a);
+    }
+  }
+});
+
+// node_modules/@coderifts/agent-guard/dist/cjs/monitoring-delivery.js
+var require_monitoring_delivery = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/monitoring-delivery.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DEFAULT_MONITORING_SINK_TIMEOUT_MS = void 0;
+    exports2.ackBytes = ackBytes;
+    exports2.verifyAckHmac = verifyAckHmac;
+    exports2.deliverMonitoring = deliverMonitoring;
+    exports2.formatMonitoringDeliveryLine = formatMonitoringDeliveryLine;
+    exports2.monitoringDeliveryFailClosed = monitoringDeliveryFailClosed;
+    var node_crypto_1 = require("node:crypto");
+    exports2.DEFAULT_MONITORING_SINK_TIMEOUT_MS = 5e3;
+    var HMAC_HEADER_NAMES = [
+      "x-coderifts-ack-signature",
+      "x-hub-signature-256",
+      "x-signature"
+    ];
+    function sha256Prefixed(bytes) {
+      return "sha256:" + (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+    }
+    function ackBytes(ack) {
+      if (ack == null)
+        return Buffer.alloc(0);
+      if (typeof ack === "string")
+        return Buffer.from(ack, "utf8");
+      if (Buffer.isBuffer(ack))
+        return ack;
+      if (typeof ack === "number" || typeof ack === "boolean")
+        return Buffer.from(String(ack), "utf8");
+      try {
+        return Buffer.from(JSON.stringify(ack), "utf8");
+      } catch {
+        return Buffer.from(String(ack), "utf8");
+      }
+    }
+    function normalizeSig(raw) {
+      return raw.trim().toLowerCase().replace(/^sha256=/, "");
+    }
+    function verifyAckHmac(ack, signature, key) {
+      const expectedHex = (0, node_crypto_1.createHmac)("sha256", key).update(ack).digest("hex");
+      const gotHex = normalizeSig(signature);
+      if (!/^[0-9a-f]+$/.test(gotHex) || gotHex.length !== expectedHex.length)
+        return false;
+      try {
+        return (0, node_crypto_1.timingSafeEqual)(Buffer.from(gotHex, "hex"), Buffer.from(expectedHex, "hex"));
+      } catch {
+        return false;
+      }
+    }
+    function headerGet(headers, name) {
+      if (!headers)
+        return null;
+      if (typeof headers.get === "function") {
+        const v = headers.get(name);
+        return v == null ? null : String(v);
+      }
+      const rec = headers;
+      const key = Object.keys(rec).find((k) => k.toLowerCase() === name.toLowerCase());
+      return key != null ? String(rec[key]) : null;
+    }
+    function pickSignature(hdrs) {
+      if (!hdrs)
+        return null;
+      for (const n of HMAC_HEADER_NAMES) {
+        const v = headerGet(hdrs, n);
+        if (v)
+          return v;
+      }
+      return null;
+    }
+    function signatureFromAckValue(ack) {
+      if (!ack || typeof ack !== "object" || Array.isArray(ack))
+        return null;
+      const o = ack;
+      for (const k of ["signature", "ack_signature", "hmac"]) {
+        if (typeof o[k] === "string" && o[k])
+          return o[k];
+      }
+      return null;
+    }
+    function ackMaterial(raw) {
+      const signature = signatureFromAckValue(raw);
+      if (raw && typeof raw === "object" && !Array.isArray(raw) && !Buffer.isBuffer(raw)) {
+        const o = raw;
+        if ("ack" in o)
+          return { bytes: ackBytes(o.ack), signature };
+        if ("body" in o)
+          return { bytes: ackBytes(o.body), signature };
+        const copy = { ...o };
+        delete copy.signature;
+        delete copy.ack_signature;
+        delete copy.hmac;
+        return { bytes: ackBytes(copy), signature };
+      }
+      return { bytes: ackBytes(raw), signature };
+    }
+    function withTimeout(p, ms) {
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          reject(Object.assign(new Error(`monitoring sink timed out after ${ms}ms`), { name: "TimeoutError" }));
+        }, Math.max(1, ms));
+        p.then((v) => {
+          clearTimeout(timer);
+          resolve(v);
+        }, (e) => {
+          clearTimeout(timer);
+          reject(e);
+        });
+      });
+    }
+    function hmacResult(ack, signature, key) {
+      if (key == null || String(key).length === 0)
+        return { ok: true };
+      if (!signature)
+        return { ok: false, reason: "ack_hmac_missing" };
+      if (!verifyAckHmac(ack, signature, key))
+        return { ok: false, reason: "ack_hmac_invalid" };
+      return { ok: true, verified: true };
+    }
+    async function deliverCallback(sink, payload, timeoutMs, ackHmacKey, at) {
+      try {
+        const raw = await withTimeout(Promise.resolve(sink(payload)), timeoutMs);
+        if (raw === void 0 || raw === null) {
+          return {
+            status: "sent_unacked",
+            evidence: { at, sink_kind: "callback" }
+          };
+        }
+        const { bytes, signature } = ackMaterial(raw);
+        const hmac = hmacResult(bytes, signature, ackHmacKey);
+        if (!hmac.ok) {
+          return {
+            status: "not_delivered",
+            evidence: { at, sink_kind: "callback", ack_hash: sha256Prefixed(bytes) },
+            reason: hmac.reason
+          };
+        }
+        const evidence = {
+          at,
+          sink_kind: "callback",
+          ack_hash: sha256Prefixed(bytes)
+        };
+        if (hmac.verified === true)
+          evidence.ack_verified = true;
+        return { status: "delivered_acked", evidence };
+      } catch (err) {
+        const name = err && typeof err === "object" ? err.name : "";
+        const reason = name === "TimeoutError" ? "timeout" : "threw";
+        return {
+          status: "not_delivered",
+          evidence: { at, sink_kind: "callback" },
+          reason
+        };
+      }
+    }
+    async function deliverHttp(sink, payload, timeoutMs, ackHmacKey, at) {
+      const fetchImpl = sink.fetchImpl || globalThis.fetch;
+      if (typeof fetchImpl !== "function") {
+        return {
+          status: "not_delivered",
+          evidence: { at, sink_kind: "http" },
+          reason: "fetch_unavailable"
+        };
+      }
+      try {
+        const resp = await withTimeout(fetchImpl(sink.url, {
+          method: "POST",
+          headers: { "content-type": "application/json", ...sink.headers || {} },
+          body: JSON.stringify(payload)
+        }), timeoutMs);
+        const status_code = resp.status;
+        if (!resp.ok || status_code < 200 || status_code >= 300) {
+          return {
+            status: "not_delivered",
+            evidence: { at, sink_kind: "http", status_code },
+            reason: `http_${status_code}`
+          };
+        }
+        let body = "";
+        try {
+          body = await resp.text();
+        } catch {
+          body = "";
+        }
+        const bytes = Buffer.from(body, "utf8");
+        const key = sink.ackHmacKey != null ? sink.ackHmacKey : ackHmacKey;
+        const sig = pickSignature(resp.headers);
+        const hmac = hmacResult(bytes, sig, key);
+        if (!hmac.ok) {
+          return {
+            status: "not_delivered",
+            evidence: { at, sink_kind: "http", status_code, ack_hash: sha256Prefixed(bytes) },
+            reason: hmac.reason
+          };
+        }
+        const evidence = {
+          at,
+          sink_kind: "http",
+          status_code
+        };
+        if (bytes.length > 0)
+          evidence.ack_hash = sha256Prefixed(bytes);
+        if (hmac.verified === true)
+          evidence.ack_verified = true;
+        return { status: "delivered_acked", evidence };
+      } catch (err) {
+        const name = err && typeof err === "object" ? err.name : "";
+        const reason = name === "TimeoutError" ? "timeout" : "threw";
+        return {
+          status: "not_delivered",
+          evidence: { at, sink_kind: "http" },
+          reason
+        };
+      }
+    }
+    function isHttpSink(sink) {
+      return typeof sink === "object" && sink != null && typeof sink.url === "string";
+    }
+    async function deliverMonitoring(args) {
+      const at = args.now;
+      const timeoutMs = args.timeoutMs ?? exports2.DEFAULT_MONITORING_SINK_TIMEOUT_MS;
+      if (args.sink == null) {
+        return { status: "sent_unacked", evidence: { at, sink_kind: "callback" } };
+      }
+      if (typeof args.sink === "function") {
+        return deliverCallback(args.sink, args.payload, timeoutMs, args.ackHmacKey, at);
+      }
+      if (isHttpSink(args.sink)) {
+        return deliverHttp(args.sink, args.payload, timeoutMs, args.ackHmacKey, at);
+      }
+      return {
+        status: "not_delivered",
+        evidence: { at, sink_kind: "callback" },
+        reason: "sink_unrecognised"
+      };
+    }
+    function formatMonitoringDeliveryLine(d) {
+      if (d.status === "sent_unacked")
+        return "monitoring: sent, not acked";
+      if (d.status === "not_delivered") {
+        return d.reason ? `monitoring: NOT delivered (${d.reason})` : "monitoring: NOT delivered";
+      }
+      const ev = d.evidence;
+      if (ev && ev.ack_hash) {
+        const short = ev.ack_hash.replace(/^sha256:/, "").slice(0, 12);
+        return `monitoring: delivered (acked sha256:${short}\u2026)`;
+      }
+      if (ev && typeof ev.status_code === "number") {
+        return `monitoring: delivered (acked HTTP ${ev.status_code})`;
+      }
+      return "monitoring: delivered (acked)";
+    }
+    function monitoringDeliveryFailClosed(config) {
+      if (config.observeOnly === true)
+        return false;
+      if (config.failPolicy === "open")
+        return false;
+      return true;
     }
   }
 });
@@ -67090,6 +69154,9 @@ var require_guard = __commonJS({
     var execution_proof_js_1 = require_execution_proof();
     var freshness_js_1 = require_freshness();
     var conditional_write_js_1 = require_conditional_write();
+    var commit_observation_js_1 = require_commit_observation();
+    var cas_attestation_js_1 = require_cas_attestation();
+    var monitoring_delivery_js_1 = require_monitoring_delivery();
     var breakers = /* @__PURE__ */ new WeakMap();
     var nowMs = () => Date.now();
     var iso = () => (/* @__PURE__ */ new Date()).toISOString();
@@ -67215,57 +69282,105 @@ var require_guard = __commonJS({
         return { verified: null, cause: "RECEIPT_UNVERIFIED" };
       }
     }
-    async function runEnforced(config, factory, approved, redacted, freshness, conditional_write) {
+    async function runEnforced(config, factory, approved, redacted, freshness, conditional_write, monitoring_delivery) {
       emit(config, { type: "execution_started", at: iso(), action: approved.action, decisionId: approved.envelope.decision_id });
       try {
         const result = await factory(approved.envelope, redacted);
         const base = { executionAttempted: true, executed: true, enforced: true, result, verdict: approved, preflighted: true };
-        return {
-          ...base,
-          proof: (0, execution_proof_js_1.buildExecutionProof)({ ...base, conditionalWriteBasis: conditional_write }),
-          freshness,
-          conditional_write
-        };
+        return finishExecuted(config, base, freshness, conditional_write, redacted, result, monitoring_delivery);
       } catch (error) {
         emit(config, { type: "factory_error", at: iso(), action: approved.action });
         const base = { executionAttempted: true, executed: false, enforced: true, error, verdict: approved, preflighted: true };
-        return {
-          ...base,
-          proof: (0, execution_proof_js_1.buildExecutionProof)({ ...base, conditionalWriteBasis: conditional_write }),
-          freshness,
-          conditional_write
-        };
+        return finishExecuted(config, base, freshness, conditional_write, redacted, void 0, monitoring_delivery);
       }
     }
-    async function runUnenforced(config, factory, envelope, verdict, preflighted, redacted, freshness, conditional_write) {
+    async function runUnenforced(config, factory, envelope, verdict, preflighted, redacted, freshness, conditional_write, monitoring_delivery) {
       emit(config, { type: "execution_started", at: iso() });
       try {
         const result = await factory(envelope, redacted);
         const base = { executionAttempted: true, executed: true, enforced: false, result, verdict, preflighted };
-        return {
-          ...base,
-          proof: (0, execution_proof_js_1.buildExecutionProof)({ ...base, conditionalWriteBasis: conditional_write }),
-          freshness,
-          conditional_write
-        };
+        return finishExecuted(config, base, freshness, conditional_write, redacted, result, monitoring_delivery);
       } catch (error) {
         emit(config, { type: "factory_error", at: iso() });
         const base = { executionAttempted: true, executed: false, enforced: false, error, verdict, preflighted };
-        return {
-          ...base,
-          proof: (0, execution_proof_js_1.buildExecutionProof)({ ...base, conditionalWriteBasis: conditional_write }),
-          freshness,
-          conditional_write
-        };
+        return finishExecuted(config, base, freshness, conditional_write, redacted, void 0, monitoring_delivery);
       }
     }
-    function blocked(verdict, preflighted, freshness, conditional_write) {
+    function blocked(verdict, preflighted, freshness, conditional_write, monitoring_delivery) {
+      const commit_observation = {
+        status: "not_observed",
+        observed_at: iso(),
+        host_attestation: "absent"
+      };
       const base = { executionAttempted: false, executed: false, enforced: false, verdict, preflighted };
       return {
         ...base,
-        proof: (0, execution_proof_js_1.buildExecutionProof)({ ...base, conditionalWriteBasis: conditional_write }),
+        proof: (0, execution_proof_js_1.buildExecutionProof)({
+          ...base,
+          conditionalWriteBasis: conditional_write,
+          commitObservation: commit_observation,
+          monitoringDelivery: monitoring_delivery
+        }),
+        freshness,
+        conditional_write,
+        commit_observation,
+        ...monitoring_delivery ? { monitoring_delivery } : {}
+      };
+    }
+    async function finishExecuted(config, base, freshness, conditional_write, redacted, result, monitoring_delivery) {
+      const enabled = config.requireCommitObservation !== false;
+      const commit_observation = await (0, commit_observation_js_1.observeCommit)({
+        enabled,
+        call: redacted,
+        result,
+        now: iso(),
+        preflightOnObserved: (artifacts) => preflightWithRetry(config, {
+          artifacts,
+          context: { operation: config.operation ?? "tool_call", environment: config.environment, audience: config.audience },
+          previous_receipt: resolvePreviousReceipt(config)
+        })
+      });
+      if (!enabled) {
+        emit(config, {
+          type: "commit_observation_check_disabled",
+          at: iso(),
+          cause: "requireCommitObservation_false"
+        });
+      } else if (commit_observation.status === "observed_drift") {
+        emit(config, {
+          type: "commit_observed_drift",
+          at: iso(),
+          observed_fp: commit_observation.observed_fp,
+          expected_fp: commit_observation.expected_fp,
+          token: commit_observation.token
+        });
+      }
+      const cas_evidence = result !== void 0 ? (0, cas_attestation_js_1.evaluateCasEvidence)(result, {
+        registry: config.executorAttestation && config.executorAttestation.registry
+      }) : void 0;
+      const proof = (0, execution_proof_js_1.buildExecutionProof)({
+        ...base,
+        conditionalWriteBasis: conditional_write,
+        commitObservation: commit_observation,
+        monitoringDelivery: monitoring_delivery,
+        ...cas_evidence ? { casEvidence: cas_evidence } : {}
+      });
+      if (result !== void 0 && (0, cas_attestation_js_1.isExecuteIfUnchangedOutcome)(result)) {
+        try {
+          (0, cas_attestation_js_1.buildCasAttestation)(proof, result, {
+            registry: config.executorAttestation && config.executorAttestation.registry
+          });
+        } catch {
+        }
+      }
+      return {
+        ...base,
+        proof,
         freshness,
-        conditional_write
+        conditional_write,
+        commit_observation,
+        ...monitoring_delivery ? { monitoring_delivery } : {},
+        ...cas_evidence ? { cas_evidence } : {}
       };
     }
     function preflightBeforeByIdFrom(arts) {
@@ -67427,7 +69542,11 @@ var require_guard = __commonJS({
         breakerRecord(config);
         return closedIntegrity(config, "EXECUTION_ACTION_UNRECOGNISED", failPolicy, fctx, cwctx, redacted, detection.artifacts);
       }
-      if (rd.reason === "UNREADABLE_DECISION" || !rd.envelope) {
+      if (rd.reason === "UNREADABLE_DECISION") {
+        breakerRecord(config);
+        return closedIntegrity(config, "UNREADABLE_DECISION", failPolicy, fctx, cwctx, redacted, detection.artifacts);
+      }
+      if (!rd.envelope) {
         breakerRecord(config);
         return closedIntegrity(config, "SCHEMA_INVALID", failPolicy, fctx, cwctx, redacted, detection.artifacts);
       }
@@ -67470,6 +69589,41 @@ var require_guard = __commonJS({
         else
           emit(config, { type: "monitoring_unwired", at: iso(), decisionId: envelope.decision_id });
       }
+      let monitoringDelivery;
+      if (kind === "MONITOR") {
+        if (!sinkWired) {
+          monitoringDelivery = {
+            status: "not_delivered",
+            evidence: { at: iso(), sink_kind: "callback" },
+            reason: "sink_not_wired"
+          };
+        } else {
+          monitoringDelivery = await (0, monitoring_delivery_js_1.deliverMonitoring)({
+            sink: config.monitoringSink,
+            timeoutMs: config.monitoringSinkTimeoutMs,
+            ackHmacKey: config.ackHmacKey,
+            payload: {
+              at: iso(),
+              decision_id: typeof envelope.decision_id === "string" ? envelope.decision_id : void 0,
+              action: "CONTINUE_WITH_MONITORING",
+              kind: "MONITOR"
+            },
+            now: iso()
+          });
+          if (monitoringDelivery.status === "not_delivered") {
+            emit(config, {
+              type: "monitoring_not_delivered",
+              at: iso(),
+              decisionId: envelope.decision_id,
+              cause: monitoringDelivery.reason
+            });
+            if ((0, monitoring_delivery_js_1.monitoringDeliveryFailClosed)(config)) {
+              breakerRecord(config);
+              return closedIntegrity(config, "MONITORING_UNWIRED", failPolicy, fctx, cwctx, redacted, detection.artifacts, monitoringDelivery);
+            }
+          }
+        }
+      }
       const { basis: freshBasis, blockCause: freshBlock } = freshnessFor(config, redacted, fctx, detection.artifacts);
       if (freshBlock === "FRESHNESS_REQUIRED" || freshBlock === "FRESHNESS_FAILED") {
         breakerRecord(config);
@@ -67483,7 +69637,11 @@ var require_guard = __commonJS({
       if (config.observeOnly) {
         emit(config, { type: "observe_only_passthrough", at: iso(), action: closedAction });
         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, freshBasis, cwBasis);
+        return runUnenforced(config, executeFactory, envelope, verdict, true, redacted, freshBasis, cwBasis, monitoringDelivery);
+      }
+      if (kind === "MONITOR" && sinkWired && monitoringDelivery && monitoringDelivery.status === "not_delivered") {
+        const degraded = { kind: "MONITOR", action: "CONTINUE_WITH_MONITORING", envelope, receiptVerified };
+        return runUnenforced(config, executeFactory, envelope, degraded, true, redacted, freshBasis, cwBasis, monitoringDelivery);
       }
       const enforceable = receiptVerified && (kind === "ALLOW" || sinkWired);
       if (enforceable) {
@@ -67496,7 +69654,7 @@ var require_guard = __commonJS({
             cause: "requireExecutionStateMatch_false"
           });
           const offVerdict = kind === "ALLOW" ? { kind: "ALLOW", action: "CONTINUE", envelope, receiptVerified } : { kind: "MONITOR", action: "CONTINUE_WITH_MONITORING", envelope, receiptVerified };
-          return runUnenforced(config, executeFactory, envelope, offVerdict, true, redacted, freshBasis, cwBasis);
+          return runUnenforced(config, executeFactory, envelope, offVerdict, true, redacted, freshBasis, cwBasis, monitoringDelivery);
         }
         const et = (0, execution_time_fingerprint_js_1.checkExecutionTimeFingerprint)({
           artifacts: detection.artifacts,
@@ -67533,21 +69691,21 @@ var require_guard = __commonJS({
             });
           }
           const warnVerdict = kind === "ALLOW" ? { kind: "ALLOW", action: "CONTINUE", envelope, receiptVerified } : { kind: "MONITOR", action: "CONTINUE_WITH_MONITORING", envelope, receiptVerified };
-          return runUnenforced(config, executeFactory, envelope, warnVerdict, true, redacted, freshBasis, cwBasis);
+          return runUnenforced(config, executeFactory, envelope, warnVerdict, true, redacted, freshBasis, cwBasis, monitoringDelivery);
         }
         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, freshBasis, cwBasis);
+        return runEnforced(config, executeFactory, approved, redacted, freshBasis, cwBasis, monitoringDelivery);
       }
       breakerRecord(config);
-      return closedIntegrity(config, receiptVerified ? "MONITORING_UNWIRED" : "RECEIPT_MISSING", failPolicy, fctx, cwctx, redacted, detection.artifacts);
+      return closedIntegrity(config, receiptVerified ? "MONITORING_UNWIRED" : "RECEIPT_MISSING", failPolicy, fctx, cwctx, redacted, detection.artifacts, monitoringDelivery);
     }
-    function closedIntegrity(config, cause, failPolicy, fctx, cwctx, redacted, arts) {
+    function closedIntegrity(config, cause, failPolicy, fctx, cwctx, redacted, arts, monitoring_delivery) {
       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);
       const { basis } = freshnessFor(config, redacted, fctx, arts);
       const { basis: cw } = conditionalWriteFor(config, redacted, cwctx);
-      return blocked(v, false, basis, cw);
+      return blocked(v, false, basis, cw, monitoring_delivery);
     }
     function isExpired(envelope) {
       const exp = envelope.expires_at;
@@ -67984,6 +70142,7 @@ var require_final_answer_proof = __commonJS({
     exports2.renderFinalAnswerProof = renderFinalAnswerProof;
     exports2.attachProofToAgentResponse = attachProofToAgentResponse;
     var execution_proof_js_1 = require_execution_proof();
+    var monitoring_delivery_js_1 = require_monitoring_delivery();
     function deriveProofBanner(proof) {
       if (!proof || typeof proof !== "object")
         return "NO_PREFLIGHT";
@@ -68042,6 +70201,7 @@ var require_final_answer_proof = __commonJS({
         "Calls outside the guarded path are invisible to this proof.",
         "execution_result_hash is NOT proof that applied artifacts match change_fp.",
         "conditional_write:true is host-asserted (the host says it conditioned on a version token); it is NOT independently CAS-verified by the guard.",
+        ...L.commit_observation_is_observed_at_t3_not_atomic === true ? ["commit_observation is observed at T3, not atomic: another writer may act between write and observation; token-only adapters compare version token not content; host attestation is a host claim layered on the measurement"] : [],
         // Machine keys for greppability (still honest if someone only reads keys).
         `limits.does_not_claim_host_cannot_bypass=${L.does_not_claim_host_cannot_bypass === true}`,
         `limits.calls_outside_guarded_path_invisible=${L.calls_outside_guarded_path_invisible === true}`,
@@ -68079,6 +70239,12 @@ var require_final_answer_proof = __commonJS({
       lines.push(bullet(`receipt.verified: ${yn(proof.receipt.verified === true)}`));
       lines.push(bullet(`receipt.status: ${proof.receipt.status != null ? proof.receipt.status : "null (not verified / no receipt path)"}`));
       lines.push(bullet(`receipt.expires_at: ${proof.receipt.expires_at != null ? proof.receipt.expires_at : "(none)"}`));
+      const trail = proof.recheck_trail;
+      if (Array.isArray(trail) && trail.length > 1) {
+        const n = trail.length - 1;
+        const id = proof.decision_id != null ? proof.decision_id : "(none)";
+        lines.push(bullet(`re-preflighted ${n}\xD7 after remediation; final decision ${id}`));
+      }
       lines.push("");
       lines.push(h2("Authorization"));
       lines.push(bullet(`currently_authorized: ${formatAuthz(proof.currently_authorized)}`));
@@ -68106,6 +70272,40 @@ var require_final_answer_proof = __commonJS({
       lines.push(bullet(`enforced: ${yn(proof.execution.enforced === true)}`));
       lines.push(bullet(`execution_result_hash: ${formatResultHash(proof.execution_result_hash)}`));
       lines.push("");
+      const co = proof.commit_observation;
+      if (co && typeof co === "object") {
+        lines.push(h2("Commit observation (T3)"));
+        lines.push(bullet(`status: ${co.status}`));
+        lines.push(bullet(`observed_at: ${co.observed_at || "(none)"}`));
+        if (co.host_attestation)
+          lines.push(bullet(`host_attestation: ${co.host_attestation}`));
+        if (co.observed_fp)
+          lines.push(bullet(`observed_fp: ${co.observed_fp}`));
+        if (co.expected_fp)
+          lines.push(bullet(`expected_fp: ${co.expected_fp}`));
+        if (co.token)
+          lines.push(bullet(`token: ${co.token}`));
+        const ce = proof.cas_evidence;
+        if (ce && ce.class === "executor_attested") {
+          const kid = ce.executor_kid != null ? ce.executor_kid : "\u2026";
+          const st = ce.attest_status != null ? ce.attest_status : "ATTEST_VALID";
+          lines.push(bullet(`committed \u2014 executor-attested (${st}, kid ${kid})`));
+          lines.push(bullet("Observed at T3, not atomic: another writer may act between write and observation; token-only adapters compare version token not content."));
+        } else if (ce && ce.class === "host_claimed" && ce.attest_status) {
+          lines.push(bullet(`committed \u2014 host-claimed (attest_status ${ce.attest_status})`));
+          lines.push(bullet("Observed at T3, not atomic: another writer may act between write and observation; token-only adapters compare version token not content; host attestation is a host claim layered on the measurement."));
+        } else {
+          lines.push(bullet("Observed at T3, not atomic: another writer may act between write and observation; token-only adapters compare version token not content; host attestation is a host claim layered on the measurement."));
+        }
+        lines.push("");
+      }
+      const mdv = proof.monitoring_delivery;
+      if (mdv && typeof mdv === "object" && typeof mdv.status === "string") {
+        lines.push(h2("Monitoring delivery"));
+        lines.push(bullet((0, monitoring_delivery_js_1.formatMonitoringDeliveryLine)(mdv)));
+        lines.push(bullet("delivered_acked means the sink returned an ack \u2014 it does NOT mean a human saw the event."));
+        lines.push("");
+      }
       lines.push(h2("Limits (non-claims \u2014 always true on this proof)"));
       for (const L of limitLines(proof)) {
         lines.push(bullet(L));
@@ -68152,546 +70352,6 @@ var require_final_answer_proof = __commonJS({
   }
 });
 
-// node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/fs.js
-var require_fs = __commonJS({
-  "node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/fs.js"(exports2) {
-    "use strict";
-    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      var desc = Object.getOwnPropertyDescriptor(m, k);
-      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-        desc = { enumerable: true, get: function() {
-          return m[k];
-        } };
-      }
-      Object.defineProperty(o, k2, desc);
-    }) : (function(o, m, k, k2) {
-      if (k2 === void 0) k2 = k;
-      o[k2] = m[k];
-    }));
-    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function(o, v) {
-      o["default"] = v;
-    });
-    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ (function() {
-      var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function(o2) {
-          var ar = [];
-          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
-          return ar;
-        };
-        return ownKeys(o);
-      };
-      return function(mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) {
-          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        }
-        __setModuleDefault(result, mod);
-        return result;
-      };
-    })();
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.tokensEqual = exports2.FS_ABSENT_TOKEN = exports2.FS_VERSION_TOKEN_PREFIX = void 0;
-    exports2.fsTokenContentHash = fsTokenContentHash;
-    exports2.createFsVersionToken = createFsVersionToken;
-    exports2.readVersionedFile = readVersionedFile;
-    exports2.writeFileIfUnchanged = writeFileIfUnchanged;
-    exports2.createFsPriorContentResolver = createFsPriorContentResolver;
-    var node_crypto_1 = require("node:crypto");
-    var node_fs_1 = require("node:fs");
-    var path = __importStar(require("node:path"));
-    var conditional_write_js_1 = require_conditional_write();
-    Object.defineProperty(exports2, "tokensEqual", { enumerable: true, get: function() {
-      return conditional_write_js_1.tokensEqual;
-    } });
-    exports2.FS_VERSION_TOKEN_PREFIX = "fs:v1:";
-    exports2.FS_ABSENT_TOKEN = "fs:v1:absent";
-    function sha256hex(buf) {
-      return (0, node_crypto_1.createHash)("sha256").update(buf).digest("hex");
-    }
-    function fsTokenContentHash(token) {
-      if (typeof token !== "string" || !token.startsWith(exports2.FS_VERSION_TOKEN_PREFIX))
-        return null;
-      if (token === exports2.FS_ABSENT_TOKEN)
-        return null;
-      const rest = token.slice(exports2.FS_VERSION_TOKEN_PREFIX.length);
-      const colon = rest.indexOf(":");
-      if (colon < 0)
-        return null;
-      const hash = rest.slice(colon + 1);
-      return /^[a-f0-9]{64}$/.test(hash) ? hash : null;
-    }
-    async function createFsVersionToken(filePath) {
-      let st;
-      try {
-        st = await node_fs_1.promises.stat(filePath);
-      } catch (err) {
-        const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
-        if (code === "ENOENT")
-          return exports2.FS_ABSENT_TOKEN;
-        throw err;
-      }
-      if (!st.isFile()) {
-        throw new Error(`createFsVersionToken: not a regular file: ${filePath}`);
-      }
-      const buf = await node_fs_1.promises.readFile(filePath);
-      const hash = sha256hex(buf);
-      const mtimeMs = Math.trunc(st.mtimeMs);
-      return `${exports2.FS_VERSION_TOKEN_PREFIX}${mtimeMs}:${hash}`;
-    }
-    async function readVersionedFile(filePath) {
-      const version_token = await createFsVersionToken(filePath);
-      if (version_token === exports2.FS_ABSENT_TOKEN) {
-        return { content: "", version_token };
-      }
-      const content = await node_fs_1.promises.readFile(filePath, "utf8");
-      return { content, version_token };
-    }
-    async function writeFileIfUnchanged(args) {
-      const target = path.resolve(args.path);
-      const body = typeof args.content === "string" ? Buffer.from(args.content, "utf8") : args.content;
-      const writtenHash = sha256hex(body);
-      return (0, conditional_write_js_1.executeIfUnchanged)({
-        expected_token: args.expected_token,
-        current_token: () => createFsVersionToken(target),
-        detect_stale_during_commit: true,
-        // Post-commit: token content-hash must equal sha256 of what we wrote (mtime may vary).
-        expected_after_commit: async (result) => {
-          const post = await createFsVersionToken(target);
-          const postHash = fsTokenContentHash(post);
-          if (postHash === result.written_content_hash)
-            return post;
-          return `${exports2.FS_VERSION_TOKEN_PREFIX}0:stale_during_commit_mismatch`;
-        },
-        write: async () => {
-          const dir = path.dirname(target);
-          await node_fs_1.promises.mkdir(dir, { recursive: true });
-          const tmp = path.join(dir, `.coderifts-cas-${path.basename(target)}-${process.pid}-${(0, node_crypto_1.randomBytes)(6).toString("hex")}.tmp`);
-          try {
-            await node_fs_1.promises.writeFile(tmp, body);
-            const still = await createFsVersionToken(target);
-            if (!(0, conditional_write_js_1.tokensEqual)(args.expected_token, still)) {
-              try {
-                await node_fs_1.promises.unlink(tmp);
-              } catch {
-              }
-              throw new conditional_write_js_1.StaleVersionTokenAbort(still);
-            }
-            await node_fs_1.promises.rename(tmp, target);
-          } catch (err) {
-            if (err instanceof conditional_write_js_1.StaleVersionTokenAbort)
-              throw err;
-            try {
-              await node_fs_1.promises.unlink(tmp);
-            } catch {
-            }
-            throw err;
-          }
-          return { path: target, bytes: body.length, written_content_hash: writtenHash };
-        }
-      });
-    }
-    function createFsPriorContentResolver(options) {
-      const pathForArtifact = options?.pathForArtifact;
-      return async (req) => {
-        let filePath = typeof req.path === "string" && req.path.length > 0 ? req.path : void 0;
-        if (!filePath && pathForArtifact) {
-          const mapped = pathForArtifact(req.artifactId);
-          if (typeof mapped === "string" && mapped.length > 0)
-            filePath = mapped;
-        }
-        if (!filePath)
-          return null;
-        try {
-          return await node_fs_1.promises.readFile(filePath, "utf8");
-        } catch (err) {
-          const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
-          if (code === "ENOENT")
-            return null;
-          throw err;
-        }
-      };
-    }
-  }
-});
-
-// node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/api.js
-var require_api3 = __commonJS({
-  "node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/api.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.tokensEqual = exports2.API_ABSENT_TOKEN = exports2.API_VERSION_TOKEN_PREFIX = void 0;
-    exports2.createApiVersionToken = createApiVersionToken;
-    exports2.apiTokenRaw = apiTokenRaw;
-    exports2.writeApiIfUnchanged = writeApiIfUnchanged;
-    var conditional_write_js_1 = require_conditional_write();
-    Object.defineProperty(exports2, "tokensEqual", { enumerable: true, get: function() {
-      return conditional_write_js_1.tokensEqual;
-    } });
-    exports2.API_VERSION_TOKEN_PREFIX = "api:v1:";
-    exports2.API_ABSENT_TOKEN = "api:v1:absent";
-    function createApiVersionToken(etag) {
-      if (etag == null)
-        return exports2.API_ABSENT_TOKEN;
-      let s = String(etag).trim();
-      if (s.length === 0)
-        return exports2.API_ABSENT_TOKEN;
-      if (s.startsWith("W/") || s.startsWith("w/"))
-        s = s.slice(2).trim();
-      if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
-        s = s.slice(1, -1);
-      }
-      if (s.length === 0)
-        return exports2.API_ABSENT_TOKEN;
-      return `${exports2.API_VERSION_TOKEN_PREFIX}${s}`;
-    }
-    function apiTokenRaw(token) {
-      if (typeof token !== "string" || !token.startsWith(exports2.API_VERSION_TOKEN_PREFIX))
-        return null;
-      if (token === exports2.API_ABSENT_TOKEN)
-        return null;
-      const raw = token.slice(exports2.API_VERSION_TOKEN_PREFIX.length);
-      return raw.length > 0 ? raw : null;
-    }
-    async function writeApiIfUnchanged(args) {
-      const detect = args.detect_stale_during_commit === true;
-      return (0, conditional_write_js_1.executeIfUnchanged)({
-        expected_token: args.expected_token,
-        current_token: async () => createApiVersionToken(await args.current_etag()),
-        detect_stale_during_commit: detect,
-        expected_after_commit: detect ? async (written) => {
-          if (typeof written.new_etag === "string" && written.new_etag.trim().length > 0) {
-            return createApiVersionToken(written.new_etag);
-          }
-          return createApiVersionToken(await args.current_etag());
-        } : void 0,
-        write: async () => {
-          const report = await args.write({
-            if_match: apiTokenRaw(args.expected_token),
-            expected_token: args.expected_token
-          });
-          if (!report || typeof report !== "object") {
-            throw new Error("writeApiIfUnchanged: host write must return ApiHostWriteReport");
-          }
-          if (report.status === "precondition_failed") {
-            const cur = report.current_etag !== void 0 ? createApiVersionToken(report.current_etag) : null;
-            throw new conditional_write_js_1.StaleVersionTokenAbort(cur);
-          }
-          if (report.status !== "committed") {
-            throw new Error(`writeApiIfUnchanged: unknown host report status ${String(report.status)}`);
-          }
-          const new_etag = report.new_etag === void 0 || report.new_etag === null ? null : String(report.new_etag);
-          return {
-            new_etag,
-            result: report.result
-          };
-        }
-      });
-    }
-  }
-});
-
-// node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/db.js
-var require_db2 = __commonJS({
-  "node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/db.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.tokensEqual = exports2.DB_ABSENT_TOKEN = exports2.DB_VERSION_TOKEN_PREFIX = void 0;
-    exports2.createDbVersionToken = createDbVersionToken;
-    exports2.dbTokenRaw = dbTokenRaw;
-    exports2.writeDbIfUnchanged = writeDbIfUnchanged;
-    var conditional_write_js_1 = require_conditional_write();
-    Object.defineProperty(exports2, "tokensEqual", { enumerable: true, get: function() {
-      return conditional_write_js_1.tokensEqual;
-    } });
-    exports2.DB_VERSION_TOKEN_PREFIX = "db:v1:";
-    exports2.DB_ABSENT_TOKEN = "db:v1:absent";
-    function createDbVersionToken(version) {
-      if (version == null)
-        return exports2.DB_ABSENT_TOKEN;
-      if (typeof version === "number" && !Number.isFinite(version))
-        return exports2.DB_ABSENT_TOKEN;
-      const s = String(version).trim();
-      if (s.length === 0)
-        return exports2.DB_ABSENT_TOKEN;
-      return `${exports2.DB_VERSION_TOKEN_PREFIX}${s}`;
-    }
-    function dbTokenRaw(token) {
-      if (typeof token !== "string" || !token.startsWith(exports2.DB_VERSION_TOKEN_PREFIX))
-        return null;
-      if (token === exports2.DB_ABSENT_TOKEN)
-        return null;
-      const raw = token.slice(exports2.DB_VERSION_TOKEN_PREFIX.length);
-      return raw.length > 0 ? raw : null;
-    }
-    function normalizeDbReport(report) {
-      if ("rows_affected" in report && typeof report.rows_affected === "number") {
-        const r = report;
-        if (r.rows_affected === 0) {
-          return {
-            kind: "conflict",
-            new_version: void 0,
-            current_version: void 0,
-            rows_affected: 0
-          };
-        }
-        return {
-          kind: "committed",
-          new_version: r.new_version,
-          result: r.result,
-          rows_affected: r.rows_affected
-        };
-      }
-      if ("status" in report && report.status === "conflict") {
-        const r = report;
-        return {
-          kind: "conflict",
-          new_version: void 0,
-          current_version: r.current_version
-        };
-      }
-      if ("status" in report && report.status === "committed") {
-        const r = report;
-        return {
-          kind: "committed",
-          new_version: r.new_version,
-          result: r.result
-        };
-      }
-      throw new Error("writeDbIfUnchanged: host write must return DbHostWriteReport");
-    }
-    async function writeDbIfUnchanged(args) {
-      const detect = args.detect_stale_during_commit === true;
-      return (0, conditional_write_js_1.executeIfUnchanged)({
-        expected_token: args.expected_token,
-        current_token: async () => createDbVersionToken(await args.current_version()),
-        detect_stale_during_commit: detect,
-        expected_after_commit: detect ? async (written) => {
-          if (typeof written.new_version === "string" && written.new_version.trim().length > 0) {
-            return createDbVersionToken(written.new_version);
-          }
-          return createDbVersionToken(await args.current_version());
-        } : void 0,
-        write: async () => {
-          const report = await args.write({
-            expected_version: dbTokenRaw(args.expected_token),
-            expected_token: args.expected_token
-          });
-          const norm = normalizeDbReport(report);
-          if (norm.kind === "conflict") {
-            const cur = norm.current_version !== void 0 ? createDbVersionToken(norm.current_version) : null;
-            throw new conditional_write_js_1.StaleVersionTokenAbort(cur);
-          }
-          const new_version = norm.new_version === void 0 || norm.new_version === null ? null : String(norm.new_version);
-          return {
-            new_version,
-            result: norm.result,
-            rows_affected: norm.rows_affected
-          };
-        }
-      });
-    }
-  }
-});
-
-// node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/registry.js
-var require_registry = __commonJS({
-  "node_modules/@coderifts/agent-guard/dist/cjs/cas-adapters/registry.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.tokensEqual = exports2.REGISTRY_ABSENT_TOKEN = exports2.REGISTRY_VERSION_TOKEN_PREFIX = void 0;
-    exports2.createRegistryVersionToken = createRegistryVersionToken;
-    exports2.registryTokenRaw = registryTokenRaw;
-    exports2.writeRegistryIfUnchanged = writeRegistryIfUnchanged;
-    var conditional_write_js_1 = require_conditional_write();
-    Object.defineProperty(exports2, "tokensEqual", { enumerable: true, get: function() {
-      return conditional_write_js_1.tokensEqual;
-    } });
-    exports2.REGISTRY_VERSION_TOKEN_PREFIX = "registry:v1:";
-    exports2.REGISTRY_ABSENT_TOKEN = "registry:v1:absent";
-    function createRegistryVersionToken(token) {
-      if (token == null)
-        return exports2.REGISTRY_ABSENT_TOKEN;
-      if (typeof token === "number" && !Number.isFinite(token))
-        return exports2.REGISTRY_ABSENT_TOKEN;
-      const s = String(token).trim();
-      if (s.length === 0)
-        return exports2.REGISTRY_ABSENT_TOKEN;
-      return `${exports2.REGISTRY_VERSION_TOKEN_PREFIX}${s}`;
-    }
-    function registryTokenRaw(token) {
-      if (typeof token !== "string" || !token.startsWith(exports2.REGISTRY_VERSION_TOKEN_PREFIX)) {
-        return null;
-      }
-      if (token === exports2.REGISTRY_ABSENT_TOKEN)
-        return null;
-      const raw = token.slice(exports2.REGISTRY_VERSION_TOKEN_PREFIX.length);
-      return raw.length > 0 ? raw : null;
-    }
-    function normalizeRegistryReport(report) {
-      if (!report || typeof report !== "object") {
-        throw new Error("writeRegistryIfUnchanged: host compareAndSwap must return RegistryHostCasReport");
-      }
-      if ("swapped" in report) {
-        if (report.swapped === true) {
-          return { kind: "committed", new_token: report.new_token, result: report.result };
-        }
-        return { kind: "conflict", current_token: report.current_token };
-      }
-      if (report.status === "committed") {
-        return { kind: "committed", new_token: report.new_token, result: report.result };
-      }
-      if (report.status === "conflict") {
-        return { kind: "conflict", current_token: report.current_token };
-      }
-      throw new Error("writeRegistryIfUnchanged: unknown host report shape");
-    }
-    async function writeRegistryIfUnchanged(args) {
-      const detect = args.detect_stale_during_commit === true;
-      return (0, conditional_write_js_1.executeIfUnchanged)({
-        expected_token: args.expected_token,
-        current_token: async () => createRegistryVersionToken(await args.current_token()),
-        detect_stale_during_commit: detect,
-        expected_after_commit: detect ? async (written) => {
-          if (typeof written.new_token === "string" && written.new_token.trim().length > 0) {
-            return createRegistryVersionToken(written.new_token);
-          }
-          return createRegistryVersionToken(await args.current_token());
-        } : void 0,
-        write: async () => {
-          const report = await args.compareAndSwap({
-            expected: registryTokenRaw(args.expected_token),
-            expected_token: args.expected_token
-          });
-          const norm = normalizeRegistryReport(report);
-          if (norm.kind === "conflict") {
-            const cur = norm.current_token !== void 0 ? createRegistryVersionToken(norm.current_token) : null;
-            throw new conditional_write_js_1.StaleVersionTokenAbort(cur);
-          }
-          const new_token = norm.new_token === void 0 || norm.new_token === null ? null : String(norm.new_token);
-          return {
-            new_token,
-            result: norm.result
-          };
-        }
-      });
-    }
-  }
-});
-
-// node_modules/@coderifts/agent-guard/dist/cjs/cas-attestation.js
-var require_cas_attestation = __commonJS({
-  "node_modules/@coderifts/agent-guard/dist/cjs/cas-attestation.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.CAS_ATTESTATION_SPEC = void 0;
-    exports2.isGuardExecutionProof = isGuardExecutionProof;
-    exports2.isExecuteIfUnchangedOutcome = isExecuteIfUnchangedOutcome;
-    exports2.buildCasAttestation = buildCasAttestation;
-    var execution_proof_js_1 = require_execution_proof();
-    exports2.CAS_ATTESTATION_SPEC = "cas-attestation.v1";
-    var LIMITS = Object.freeze({
-      does_not_claim_only_write_on_host: true,
-      does_not_claim_version_token_proves_change_fp_match: true,
-      does_not_claim_committed_stale_is_safe: true,
-      does_not_claim_execution_result_hash_equals_cas_bytes: true,
-      does_not_claim_host_cannot_bypass: true,
-      does_not_claim_governance_redecision: true
-    });
-    function isGuardExecutionProof(x) {
-      if (!x || typeof x !== "object")
-        return false;
-      const p = x;
-      return p.proof_spec === execution_proof_js_1.EXECUTION_PROOF_SPEC && p.receipt != null && typeof p.receipt === "object" && p.execution_result_hash != null && typeof p.execution_result_hash === "object";
-    }
-    function isExecuteIfUnchangedOutcome(x) {
-      if (!x || typeof x !== "object")
-        return false;
-      const o = x;
-      if (o.status === "committed") {
-        const c = x;
-        return typeof c.version_token === "string";
-      }
-      if (o.status === "refused") {
-        const r = x;
-        return r.reason === "stale_version_token" && typeof r.expected_token === "string";
-      }
-      if (o.status === "committed_stale_detected") {
-        const s = x;
-        return s.reason === "stale_during_commit" && typeof s.expected_token === "string";
-      }
-      return false;
-    }
-    function freezeExecutionResultHash(h) {
-      return Object.freeze({ ...h });
-    }
-    function projectCas(outcome) {
-      if (outcome.status === "committed") {
-        return Object.freeze({
-          status: "committed",
-          write_ran: true,
-          version_token: outcome.version_token
-        });
-      }
-      if (outcome.status === "refused") {
-        return Object.freeze({
-          status: "refused",
-          write_ran: false,
-          reason: "stale_version_token",
-          expected_token: outcome.expected_token,
-          current_token: outcome.current_token == null ? null : outcome.current_token
-        });
-      }
-      return Object.freeze({
-        status: "committed_stale_detected",
-        write_ran: true,
-        reason: "stale_during_commit",
-        expected_token: outcome.expected_token,
-        post_commit_token: outcome.post_commit_token == null ? null : outcome.post_commit_token
-      });
-    }
-    function buildCasAttestation(proof, outcome) {
-      if (!isGuardExecutionProof(proof)) {
-        throw new TypeError("@coderifts/agent-guard: buildCasAttestation requires a valid guard-execution-proof.v1 object (proof_spec mismatch or missing required fields)");
-      }
-      if (!isExecuteIfUnchangedOutcome(outcome)) {
-        throw new TypeError("@coderifts/agent-guard: buildCasAttestation requires a valid ExecuteIfUnchangedOutcome (status committed | refused | committed_stale_detected with branch fields)");
-      }
-      const receipt_verified = proof.receipt.verified === true;
-      const cas = projectCas(outcome);
-      const write_ran = cas.write_ran === true;
-      const stale_during_commit = cas.status === "committed_stale_detected";
-      const refused = cas.status === "refused";
-      const authorized_and_committed = receipt_verified && cas.status === "committed";
-      const attestation = {
-        attestation_spec: exports2.CAS_ATTESTATION_SPEC,
-        references: Object.freeze({
-          decision_id: proof.decision_id,
-          change_fp: proof.binds_to != null ? proof.binds_to.change_fp : null,
-          operation: proof.binds_to != null ? proof.binds_to.operation : null,
-          execution_result_hash: freezeExecutionResultHash(proof.execution_result_hash),
-          receipt_verified
-        }),
-        cas,
-        derived: Object.freeze({
-          authorized_and_committed,
-          write_ran,
-          stale_during_commit,
-          refused
-        }),
-        limits: LIMITS
-      };
-      return freezeAttestation(attestation);
-    }
-    function freezeAttestation(a) {
-      return Object.freeze(a);
-    }
-  }
-});
-
 // node_modules/@coderifts/agent-guard/dist/cjs/remediation-loop-attestation.js
 var require_remediation_loop_attestation = __commonJS({
   "node_modules/@coderifts/agent-guard/dist/cjs/remediation-loop-attestation.js"(exports2) {
@@ -69512,6 +71172,459 @@ var require_artifact_resolver = __commonJS({
   }
 });
 
+// node_modules/@coderifts/agent-guard/dist/cjs/auto-recheck.js
+var require_auto_recheck = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/auto-recheck.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.AUTO_RECHECK_MAX_CAP = void 0;
+    exports2.clampMaxAttempts = clampMaxAttempts;
+    exports2.normalizeAutoRecheck = normalizeAutoRecheck;
+    exports2.runAutoRecheckLoop = runAutoRecheckLoop;
+    var guard_js_1 = require_guard();
+    var remediation_loop_attestation_js_1 = require_remediation_loop_attestation();
+    var artifact_resolver_js_1 = require_artifact_resolver();
+    exports2.AUTO_RECHECK_MAX_CAP = 3;
+    function iso() {
+      return (/* @__PURE__ */ new Date()).toISOString();
+    }
+    function emit(config, e) {
+      if (config.onEvent) {
+        try {
+          config.onEvent(e);
+        } catch {
+        }
+      }
+    }
+    function clampMaxAttempts(n) {
+      const v = typeof n === "number" ? n : Number(n);
+      if (!Number.isFinite(v))
+        return 0;
+      const i = Math.floor(v);
+      if (i < 1)
+        return 0;
+      return i > exports2.AUTO_RECHECK_MAX_CAP ? exports2.AUTO_RECHECK_MAX_CAP : i;
+    }
+    function normalizeAutoRecheck(raw) {
+      if (!raw || typeof raw !== "object")
+        return null;
+      const o = raw;
+      if (typeof o.applyFix !== "function")
+        return null;
+      const maxAttempts = clampMaxAttempts(o.maxAttempts);
+      if (maxAttempts < 1)
+        return null;
+      const cfg = { maxAttempts, applyFix: o.applyFix };
+      if (typeof o.resolveInput === "function")
+        cfg.resolveInput = o.resolveInput;
+      if (o.resolveConfig && typeof o.resolveConfig === "object")
+        cfg.resolveConfig = o.resolveConfig;
+      return cfg;
+    }
+    function envelopeOf(outcome) {
+      const v = outcome.verdict;
+      if (v && "envelope" in v && v.envelope && typeof v.envelope === "object") {
+        return v.envelope;
+      }
+      return null;
+    }
+    function fingerprintOf(outcome) {
+      const env = envelopeOf(outcome);
+      if (env && typeof env.fingerprint === "string" && env.fingerprint)
+        return env.fingerprint;
+      const fp = outcome.proof && outcome.proof.binds_to && outcome.proof.binds_to.change_fp;
+      return typeof fp === "string" && fp ? fp : null;
+    }
+    function decisionIdOf(outcome) {
+      const env = envelopeOf(outcome);
+      if (env && typeof env.decision_id === "string" && env.decision_id)
+        return env.decision_id;
+      const id = outcome.proof && outcome.proof.decision_id;
+      return typeof id === "string" && id ? id : null;
+    }
+    function executionActionOf(outcome) {
+      const v = outcome.verdict;
+      if (v && "action" in v && typeof v.action === "string")
+        return v.action;
+      return null;
+    }
+    function isAllowClass(outcome) {
+      const v = outcome.verdict;
+      if (!v || typeof v !== "object")
+        return false;
+      return v.kind === "ALLOW" || v.kind === "MONITOR";
+    }
+    function isBlockWithRemediation(outcome) {
+      const v = outcome.verdict;
+      if (!v || v.kind !== "BLOCK")
+        return null;
+      return (0, remediation_loop_attestation_js_1.readRemediationTransaction)(envelopeOf(outcome));
+    }
+    function trailEntry(outcome, attempt) {
+      return Object.freeze({
+        attempt,
+        decision_id: decisionIdOf(outcome),
+        fingerprint: fingerprintOf(outcome),
+        execution_action: executionActionOf(outcome)
+      });
+    }
+    function attachObservation(outcome, trail, extras) {
+      const frozenTrail = Object.freeze(trail.map((e) => Object.freeze({ ...e })));
+      const proof = Object.freeze({
+        ...outcome.proof,
+        recheck_trail: frozenTrail
+      });
+      const obs = { recheck_trail: frozenTrail };
+      if (extras.stop)
+        obs.recheck_stop_reason = extras.stop;
+      const recheckCount = Math.max(0, trail.length - 1);
+      if (extras.fixed === true) {
+        obs.fixed_after_block = { value: true, attempt_count: recheckCount };
+      } else if (trail.length > 0) {
+        obs.fixed_after_block = { value: null, attempt_count: recheckCount > 0 ? recheckCount : null };
+      }
+      return { ...outcome, proof, ...obs };
+    }
+    function withFreshArtifacts(call, artifacts) {
+      const next = { ...call, artifacts };
+      const args = next.arguments;
+      if (args && typeof args === "object" && !Array.isArray(args)) {
+        next.arguments = { ...args, artifacts };
+      }
+      return next;
+    }
+    async function freshCall(cfg, current, rebind, artifactsBeforeFix) {
+      let next = { ...current };
+      if (typeof cfg.resolveInput === "function") {
+        const input = await cfg.resolveInput();
+        const resolved = (0, artifact_resolver_js_1.resolve)(input, cfg.resolveConfig);
+        if (resolved.artifacts && resolved.artifacts.length > 0) {
+          return withFreshArtifacts(next, resolved.artifacts);
+        }
+      }
+      const hostReplacedArtifacts = Array.isArray(current.artifacts) && current.artifacts !== artifactsBeforeFix;
+      if (hostReplacedArtifacts) {
+        return withFreshArtifacts(next, current.artifacts);
+      }
+      const rebound = await Promise.resolve(rebind());
+      if (Array.isArray(rebound.artifacts) && rebound.artifacts.length > 0) {
+        return withFreshArtifacts(next, rebound.artifacts);
+      }
+      return next;
+    }
+    async function runAutoRecheckLoop(args) {
+      const cfg = normalizeAutoRecheck(args.config.autoRecheck);
+      const first = await (0, guard_js_1.guardToolCall)(args.call, args.factory, args.config, args.callContext);
+      if (!cfg)
+        return first;
+      const remediation0 = isBlockWithRemediation(first);
+      if (!remediation0)
+        return first;
+      const trail = [trailEntry(first, 0)];
+      let currentCall = args.call;
+      let previous = first;
+      let previousFp = fingerprintOf(first);
+      let remediation = remediation0;
+      for (let i = 1; i <= cfg.maxAttempts; i++) {
+        const artifactsBeforeFix = currentCall.artifacts;
+        const ctx = {
+          call: currentCall,
+          attempt: i,
+          outcome: previous
+        };
+        let applied = false;
+        try {
+          applied = await cfg.applyFix(remediation, ctx) === true;
+        } catch {
+          emit(args.config, {
+            type: "recheck_attempt",
+            at: iso(),
+            attempt: i,
+            decisionId: decisionIdOf(previous) ?? void 0,
+            from_fp: previousFp,
+            to_fp: previousFp,
+            cause: "apply_fix_threw"
+          });
+          return attachObservation(first, trail, { stop: "apply_fix_threw" });
+        }
+        if (!applied) {
+          return attachObservation(first, trail, { stop: "apply_fix_declined" });
+        }
+        currentCall = await freshCall(cfg, ctx.call, args.rebind, artifactsBeforeFix);
+        const nextCtx = args.refreshContext ? await args.refreshContext(currentCall) : args.callContext;
+        const next = await (0, guard_js_1.guardToolCall)(currentCall, args.factory, args.config, nextCtx);
+        const toFp = fingerprintOf(next);
+        trail.push(trailEntry(next, i));
+        emit(args.config, {
+          type: "recheck_attempt",
+          at: iso(),
+          attempt: i,
+          decisionId: decisionIdOf(next) ?? void 0,
+          from_fp: previousFp,
+          to_fp: toFp
+        });
+        if (previousFp != null && toFp != null && previousFp === toFp) {
+          return attachObservation(next, trail, { stop: "no_progress" });
+        }
+        if (isAllowClass(next)) {
+          return attachObservation(next, trail, { fixed: true });
+        }
+        const remNext = isBlockWithRemediation(next);
+        if (!remNext) {
+          return attachObservation(next, trail, {});
+        }
+        previous = next;
+        previousFp = toFp;
+        remediation = remNext;
+      }
+      return attachObservation(previous, trail, { stop: "exhausted" });
+    }
+  }
+});
+
+// node_modules/@coderifts/agent-guard/dist/cjs/auto-derive.js
+var require_auto_derive = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/auto-derive.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.AUTO_DERIVE_READ_TIMEOUT_MS = exports2.AUTO_DERIVE_SOURCE = void 0;
+    exports2.defaultFsReader = defaultFsReader;
+    exports2.normalizeAutoDerive = normalizeAutoDerive;
+    exports2.runAutoDerive = runAutoDerive;
+    exports2.attachDerivation = attachDerivation;
+    var node_fs_1 = require("node:fs");
+    var artifact_resolver_js_1 = require_artifact_resolver();
+    exports2.AUTO_DERIVE_SOURCE = "guard_auto_derived";
+    exports2.AUTO_DERIVE_READ_TIMEOUT_MS = 2e3;
+    function iso() {
+      return (/* @__PURE__ */ new Date()).toISOString();
+    }
+    function emit(config, e) {
+      if (config.onEvent) {
+        try {
+          config.onEvent(e);
+        } catch {
+        }
+      }
+    }
+    async function defaultFsReader(filePath) {
+      try {
+        return await node_fs_1.promises.readFile(filePath, "utf8");
+      } catch (err) {
+        const code = err && typeof err === "object" && "code" in err ? String(err.code) : "";
+        if (code === "ENOENT")
+          return null;
+        throw err;
+      }
+    }
+    function looksLikeResolveConfig(o) {
+      return "ssotPrefer" in o || "generatedGlobs" in o || "pathTypeHints" in o || "openApiAssembly" in o || "maxRefDepth" in o;
+    }
+    function looksLikeReaders(o) {
+      const r = o;
+      return typeof r.fs === "function" || typeof r.api === "function" || typeof r.db === "function" || typeof r.registry === "function";
+    }
+    function normalizeAutoDerive(raw) {
+      if (raw === true)
+        return { readers: { fs: defaultFsReader } };
+      if (!raw || raw === false || typeof raw !== "object")
+        return null;
+      const o = raw;
+      const cfg = {};
+      if (o.resolveConfig && typeof o.resolveConfig === "object")
+        cfg.resolveConfig = o.resolveConfig;
+      if (o.readers && typeof o.readers === "object") {
+        if (looksLikeReaders(o.readers)) {
+          cfg.readers = { ...o.readers };
+        } else if (looksLikeResolveConfig(o.readers)) {
+          cfg.resolveConfig = o.readers;
+        }
+      }
+      if (!cfg.readers)
+        cfg.readers = {};
+      if (typeof cfg.readers.fs !== "function")
+        cfg.readers.fs = defaultFsReader;
+      return cfg;
+    }
+    function rawRecord(args) {
+      if (!args || typeof args !== "object" || Array.isArray(args))
+        return null;
+      return args;
+    }
+    function hostSuppliedArtifacts(args) {
+      const a = rawRecord(args);
+      return !!(a && Array.isArray(a.artifacts));
+    }
+    function targetFromArgs(a) {
+      if (typeof a.path === "string" && a.path.length > 0)
+        return { kind: "fs", key: a.path };
+      if (typeof a.url === "string" && a.url.length > 0)
+        return { kind: "api", key: a.url };
+      if (typeof a.endpoint === "string" && a.endpoint.length > 0)
+        return { kind: "api", key: a.endpoint };
+      if (typeof a.table === "string" && a.table.length > 0) {
+        const id = a.id != null ? String(a.id) : "";
+        return { kind: "db", key: id ? `${a.table}/${id}` : a.table };
+      }
+      if (typeof a.key === "string" && a.key.length > 0)
+        return { kind: "registry", key: a.key };
+      return null;
+    }
+    function intendedAfter(a, before) {
+      for (const k of ["contents", "content", "new_content", "new_contents"]) {
+        if (typeof a[k] === "string")
+          return a[k];
+      }
+      const oldS = typeof a.old_string === "string" ? a.old_string : null;
+      const newS = typeof a.new_string === "string" ? a.new_string : null;
+      if (newS == null)
+        return null;
+      if (typeof before === "string" && oldS && oldS.length > 0 && before.includes(oldS)) {
+        return before.replace(oldS, newS);
+      }
+      if (newS.length > 0)
+        return newS;
+      return null;
+    }
+    function typeForTarget(target, a, resolveConfig) {
+      if (typeof a.type === "string" && a.type) {
+        const t = a.type;
+        if (t === "openapi" || t === "graphql" || t === "grpc" || t === "asyncapi" || t === "mcp_manifest") {
+          return t;
+        }
+      }
+      if (target.kind === "fs") {
+        const hinted = resolveConfig && resolveConfig.pathTypeHints ? resolveConfig.pathTypeHints[target.key] : void 0;
+        if (hinted)
+          return hinted;
+        return (0, artifact_resolver_js_1.classifyByName)(target.key);
+      }
+      return null;
+    }
+    async function withTimeout(p, ms) {
+      let timer;
+      try {
+        return await Promise.race([
+          p,
+          new Promise((_, reject) => {
+            timer = setTimeout(() => {
+              const e = new Error(`autoDerive reader timed out after ${ms}ms`);
+              e.name = "TimeoutError";
+              reject(e);
+            }, Math.max(1, ms));
+          })
+        ]);
+      } finally {
+        if (timer)
+          clearTimeout(timer);
+      }
+    }
+    async function readCurrent(readers, target) {
+      const fn = readers[target.kind];
+      if (typeof fn !== "function") {
+        const err = new Error(`autoDerive: no ${target.kind} reader`);
+        err.code = "NO_READER";
+        throw err;
+      }
+      return withTimeout(Promise.resolve(fn(target.key)), exports2.AUTO_DERIVE_READ_TIMEOUT_MS);
+    }
+    async function runAutoDerive(args) {
+      const bound = args.bound;
+      if (hostSuppliedArtifacts(args.rawArgs)) {
+        return {
+          call: bound,
+          derivation: { mode: "host_supplied", targets: [] }
+        };
+      }
+      const a = rawRecord(args.rawArgs) || rawRecord(bound.arguments);
+      if (!a) {
+        return { call: bound, derivation: { mode: "fragment_only", targets: [] } };
+      }
+      const target = targetFromArgs(a);
+      if (!target) {
+        return { call: bound, derivation: { mode: "fragment_only", targets: [] } };
+      }
+      const type = typeForTarget(target, a, args.cfg.resolveConfig);
+      if (!type) {
+        return {
+          call: bound,
+          derivation: {
+            mode: "fragment_only",
+            targets: [target],
+            notes: [{ target: target.key, note: "not_contract_path" }]
+          }
+        };
+      }
+      const readers = args.cfg.readers || { fs: defaultFsReader };
+      let before;
+      try {
+        before = await readCurrent(readers, target);
+      } catch (err) {
+        const name = err && typeof err === "object" && "name" in err ? String(err.name) : "";
+        const cause = name === "TimeoutError" ? "reader_timeout" : "reader_threw";
+        emit(args.config, { type: "derive_failed", at: iso(), cause });
+        return {
+          call: bound,
+          derivation: {
+            mode: "fragment_only",
+            targets: [target],
+            notes: [{
+              target: target.key,
+              note: cause === "reader_timeout" ? "reader_timeout" : "reader_threw"
+            }]
+          },
+          failed: { cause }
+        };
+      }
+      const after = intendedAfter(a, before);
+      if (after == null) {
+        return {
+          call: bound,
+          derivation: { mode: "fragment_only", targets: [target] }
+        };
+      }
+      const notes = [];
+      if (before === null) {
+        notes.push({ target: target.key, note: "before_unavailable" });
+        if (Array.isArray(bound.artifacts) && bound.artifacts.length > 0) {
+          return {
+            call: bound,
+            derivation: {
+              mode: "fragment_only",
+              targets: [target],
+              notes
+            }
+          };
+        }
+      }
+      const derived = {
+        id: `${type}:${target.key}`,
+        type,
+        before,
+        after,
+        source: exports2.AUTO_DERIVE_SOURCE
+      };
+      const call = {
+        ...bound,
+        artifacts: [derived]
+      };
+      return {
+        call,
+        derivation: {
+          mode: "auto_derived",
+          targets: [target],
+          ...notes.length ? { notes } : {}
+        }
+      };
+    }
+    function attachDerivation(outcome, derivation) {
+      if (!derivation)
+        return outcome;
+      return { ...outcome, derivation };
+    }
+  }
+});
+
 // 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) {
@@ -69522,6 +71635,8 @@ var require_tool_registry = __commonJS({
     var guard_js_1 = require_guard();
     var artifact_resolver_js_1 = require_artifact_resolver();
     var freshness_js_1 = require_freshness();
+    var auto_recheck_js_1 = require_auto_recheck();
+    var auto_derive_js_1 = require_auto_derive();
     var RegistryConstructionError = class extends Error {
       code;
       toolName;
@@ -69674,16 +71789,42 @@ var require_tool_registry = __commonJS({
         inputSchema: tool.inputSchema,
         meta: tool.meta,
         execute: async (args) => {
-          const call = binder(tool, args, cls);
-          const fctx = await (0, freshness_js_1.collectFreshnessCallContext)({
+          const deriveCfg = (0, auto_derive_js_1.normalizeAutoDerive)(guardCfg.autoDerive);
+          const rebindRaw = () => binder(tool, args, cls);
+          let lastDerivation = null;
+          const rebind = async () => {
+            const c = rebindRaw();
+            if (!deriveCfg)
+              return c;
+            const d = await (0, auto_derive_js_1.runAutoDerive)({
+              bound: c,
+              rawArgs: args,
+              cfg: deriveCfg,
+              config: guardCfg
+            });
+            lastDerivation = d.derivation;
+            return d.call;
+          };
+          const call = await rebind();
+          const refreshContext = async (c) => (0, freshness_js_1.collectFreshnessCallContext)({
             call: {
-              toolName: call.toolName,
-              artifacts: call.artifacts,
-              arguments: call.arguments
+              toolName: c.toolName,
+              artifacts: c.artifacts,
+              arguments: c.arguments
             },
             resolvePriorContent: guardCfg.resolvePriorContent
           });
-          return (0, guard_js_1.guardToolCall)(call, async (_envelope, redacted) => rawExecute(redacted ? redacted.arguments : args), guardCfg, fctx);
+          const fctx = await refreshContext(call);
+          const factory = async (_envelope, redacted) => rawExecute(redacted ? redacted.arguments : args);
+          const outcome = (0, auto_recheck_js_1.normalizeAutoRecheck)(guardCfg.autoRecheck) ? await (0, auto_recheck_js_1.runAutoRecheckLoop)({
+            call,
+            factory,
+            config: guardCfg,
+            callContext: fctx,
+            rebind,
+            refreshContext
+          }) : await (0, guard_js_1.guardToolCall)(call, factory, guardCfg, fctx);
+          return (0, auto_derive_js_1.attachDerivation)(outcome, lastDerivation);
         },
         _coderifts: { guarded: true, mutationClass: cls, operation }
       };
@@ -69929,12 +72070,247 @@ var require_merge_gate = __commonJS({
   }
 });
 
+// node_modules/@coderifts/agent-guard/dist/cjs/deploy-receipt-token.js
+var require_deploy_receipt_token = __commonJS({
+  "node_modules/@coderifts/agent-guard/dist/cjs/deploy-receipt-token.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.CHAIN_SIGNING_PREFIX = void 0;
+    exports2.verifyDeployReceiptToken = verifyDeployReceiptToken;
+    var node_crypto_1 = require("node:crypto");
+    var sdk_1 = require_cjs3();
+    var receipt_binding_js_1 = require_receipt_binding();
+    exports2.CHAIN_SIGNING_PREFIX = "crchain.v1";
+    function scalar(v) {
+      return v == null ? "" : String(v);
+    }
+    function reconstructInput(payload) {
+      const v1 = `${exports2.CHAIN_SIGNING_PREFIX}|${scalar(payload.kid)}|${scalar(payload.fp)}|${scalar(payload.prev)}|${scalar(payload.caller)}|${scalar(payload.ts)}`;
+      if (payload.v === 4) {
+        return `${v1}|${scalar(payload.reg)}|${scalar(payload.ir)}|${scalar(payload.expires_at)}|${scalar(payload.bh)}`;
+      }
+      if (payload.v === 3) {
+        return `${v1}|${scalar(payload.reg)}|${scalar(payload.ir)}`;
+      }
+      if (payload.v === 2) {
+        return `${v1}|${scalar(payload.reg)}`;
+      }
+      return v1;
+    }
+    function isIssueTimeWithinKeyWindow(ts, keyMeta) {
+      if (!keyMeta || keyMeta.status === "active")
+        return true;
+      if (keyMeta.status !== "retired")
+        return false;
+      if (typeof keyMeta.retired_at !== "string" || keyMeta.retired_at.length === 0)
+        return false;
+      if (typeof ts !== "string" || ts.length === 0)
+        return false;
+      const issueMs = Date.parse(ts);
+      if (!Number.isFinite(issueMs))
+        return false;
+      if (keyMeta.valid_from) {
+        const fromMs = Date.parse(keyMeta.valid_from);
+        if (Number.isFinite(fromMs) && issueMs < fromMs)
+          return false;
+      }
+      const retiredMs = Date.parse(keyMeta.retired_at);
+      if (!Number.isFinite(retiredMs))
+        return false;
+      if (issueMs >= retiredMs)
+        return false;
+      return true;
+    }
+    function resolveKey(kid, registry, pinnedKeyPem) {
+      if (typeof pinnedKeyPem === "string" && pinnedKeyPem.trim().length > 0) {
+        try {
+          return {
+            publicKey: (0, node_crypto_1.createPublicKey)(pinnedKeyPem),
+            status: "active",
+            valid_from: null,
+            retired_at: null
+          };
+        } catch {
+          return null;
+        }
+      }
+      if (!registry || !Array.isArray(registry.keys) || !kid)
+        return null;
+      const matches = registry.keys.filter((k) => k && k.kid === kid && typeof k.public_key_pem === "string");
+      if (matches.length === 0)
+        return null;
+      const entry = matches.find((k) => k.status === "active") || matches[0];
+      try {
+        return {
+          publicKey: (0, node_crypto_1.createPublicKey)(entry.public_key_pem),
+          status: entry.status === "retired" ? "retired" : "active",
+          valid_from: entry.valid_from || null,
+          retired_at: entry.retired_at || null
+        };
+      } catch {
+        return null;
+      }
+    }
+    function fail(status, denyReason, extra = {}) {
+      return {
+        valid: false,
+        status,
+        currently_authorized: false,
+        authz_reason: extra.authz_reason ?? denyReason,
+        denyReason,
+        view: null,
+        key_status: extra.key_status ?? null,
+        payload: extra.payload
+      };
+    }
+    function viewFromEnvelope(envelope, payload, currently_authorized) {
+      const artifact = envelope.target_id ?? envelope.artifact_digest ?? envelope.bound_artifact_id;
+      return {
+        currently_authorized,
+        decision: typeof envelope.decision === "string" ? envelope.decision : "",
+        execution_action: typeof envelope.execution_action === "string" ? envelope.execution_action : void 0,
+        operation: typeof envelope.operation === "string" ? envelope.operation : void 0,
+        bound_environment: typeof envelope.environment === "string" ? envelope.environment : null,
+        bound_artifact_id: artifact == null ? null : String(artifact),
+        verdict_fingerprint: typeof envelope.fingerprint === "string" ? envelope.fingerprint : typeof payload.fp === "string" ? payload.fp : void 0,
+        body_hash: typeof payload.bh === "string" ? payload.bh : void 0,
+        target_id: envelope.target_id == null ? void 0 : String(envelope.target_id)
+      };
+    }
+    function verifyDeployReceiptToken(input, _intended = {}, nowMs) {
+      const token = input && input.token;
+      if (typeof token !== "string" || token.length === 0) {
+        return fail("MALFORMED", "unverified_receipt_view");
+      }
+      const hasKeys = input.pinnedKeyPem && String(input.pinnedKeyPem).trim().length > 0 || input.registry && Array.isArray(input.registry.keys) && input.registry.keys.length > 0;
+      if (!hasKeys) {
+        return fail("MALFORMED", "inputs_incomplete", { authz_reason: "keys_missing" });
+      }
+      const segments = token.split(".");
+      if (segments.length !== 2 || segments.some((s) => !s)) {
+        return fail("MALFORMED", "unverified_receipt_view");
+      }
+      let payload;
+      try {
+        payload = JSON.parse(Buffer.from(segments[0], "base64url").toString("utf8"));
+      } catch {
+        return fail("MALFORMED", "unverified_receipt_view");
+      }
+      if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return fail("MALFORMED", "unverified_receipt_view");
+      }
+      if (typeof payload.v === "number" && payload.v > 4) {
+        return fail("UNSUPPORTED_VERSION", "unverified_receipt_view", { payload });
+      }
+      const kid = typeof payload.kid === "string" ? payload.kid : "";
+      const resolved = resolveKey(kid, input.registry, input.pinnedKeyPem);
+      if (!resolved)
+        return fail("UNKNOWN_KEY", "unknown_key", { payload });
+      let sigOk = false;
+      try {
+        sigOk = (0, node_crypto_1.verify)(null, Buffer.from(reconstructInput(payload), "utf8"), resolved.publicKey, Buffer.from(segments[1], "base64url"));
+      } catch {
+        return fail("INVALID_SIGNATURE", "invalid_signature", { payload });
+      }
+      if (!sigOk)
+        return fail("INVALID_SIGNATURE", "invalid_signature", { payload });
+      for (const k of ["kid", "fp", "prev", "caller", "ts", "reg", "ir", "expires_at", "bh"]) {
+        if (typeof payload[k] === "string" && payload[k].includes("|")) {
+          return fail("INVALID_SIGNATURE", "invalid_signature", { payload, authz_reason: "delimiter_in_field" });
+        }
+      }
+      if (resolved.status === "retired") {
+        if (!isIssueTimeWithinKeyWindow(typeof payload.ts === "string" ? payload.ts : void 0, resolved)) {
+          return fail("INVALID_SIGNATURE", "invalid_signature", { payload, authz_reason: "retired_key_outside_window" });
+        }
+        const envelope2 = input.decision_result && typeof input.decision_result === "object" ? input.decision_result : void 0;
+        const view = envelope2 ? viewFromEnvelope(envelope2, payload, false) : null;
+        return {
+          valid: true,
+          status: "RETIRED_KEY_VALID_AT_ISSUE",
+          currently_authorized: false,
+          authz_reason: "retired_key",
+          denyReason: "retired_key",
+          payload,
+          view,
+          key_status: "retired"
+        };
+      }
+      if (payload.v === 4 && typeof payload.expires_at === "string") {
+        const exp = Date.parse(payload.expires_at);
+        const now = Number.isFinite(nowMs) ? nowMs : Date.now();
+        if ((0, sdk_1.isReceiptExpired)(exp, now, { environment: _intended.environment, operation: _intended.operation })) {
+          const envelope2 = input.decision_result && typeof input.decision_result === "object" ? input.decision_result : void 0;
+          return {
+            valid: true,
+            status: "VERIFIED_EXPIRED",
+            currently_authorized: false,
+            authz_reason: "expired",
+            denyReason: "expired",
+            payload,
+            view: envelope2 ? viewFromEnvelope(envelope2, payload, false) : null,
+            key_status: "active"
+          };
+        }
+      }
+      const envelope = input.decision_result && typeof input.decision_result === "object" ? input.decision_result : void 0;
+      if (!envelope) {
+        return {
+          valid: true,
+          status: "VERIFIED_CURRENT",
+          currently_authorized: false,
+          authz_reason: "receipt_context_required",
+          denyReason: "receipt_not_authorized",
+          payload,
+          view: null,
+          key_status: "active"
+        };
+      }
+      let localBh = null;
+      try {
+        localBh = (0, receipt_binding_js_1.computeBodyHash)(envelope);
+      } catch {
+        localBh = null;
+      }
+      if (typeof payload.bh !== "string" || payload.bh !== localBh) {
+        return fail("INVALID_SIGNATURE", "body_hash_mismatch", { payload, authz_reason: "body_hash_mismatch" });
+      }
+      return {
+        valid: true,
+        status: "VERIFIED_CURRENT",
+        currently_authorized: true,
+        authz_reason: "ok",
+        denyReason: null,
+        payload,
+        view: viewFromEnvelope(envelope, payload, true),
+        key_status: "active"
+      };
+    }
+  }
+});
+
 // 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.DEPLOY_RECEIPT_VIEW_SPEC = void 0;
+    exports2.asVerifiedDeployReceiptView = asVerifiedDeployReceiptView;
+    exports2.isVerifiedDeployReceiptView = isVerifiedDeployReceiptView;
     exports2.deployGate = deployGate;
+    var deploy_receipt_token_js_1 = require_deploy_receipt_token();
+    exports2.DEPLOY_RECEIPT_VIEW_SPEC = "deploy-receipt-view.v1";
+    function asVerifiedDeployReceiptView(view, verify_status = "VERIFIED_CURRENT") {
+      return {
+        ...view,
+        view_spec: exports2.DEPLOY_RECEIPT_VIEW_SPEC,
+        verified: true,
+        verify_status
+      };
+    }
+    function isVerifiedDeployReceiptView(r) {
+      return !!r && r.view_spec === exports2.DEPLOY_RECEIPT_VIEW_SPEC && r.verified === true;
+    }
     function norm(s) {
       return String(s == null ? "" : s).trim().toLowerCase();
     }
@@ -69975,14 +72351,15 @@ var require_deploy_gate = __commonJS({
       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 = {
+      let verification = { mode: "none", verify_status: null };
+      let receipt = input.receipt;
+      const detailOf = (r) => ({
         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
-      };
+        bound_environment: r && r.bound_environment != null ? norm(r.bound_environment) : null,
+        bound_artifact_id: r && r.bound_artifact_id != null ? norm(r.bound_artifact_id) : null,
+        operation: r && r.operation != null ? String(r.operation) : null
+      });
       const deny = (state, reason) => ({
         deploy_allowed: false,
         state,
@@ -69990,11 +72367,36 @@ var require_deploy_gate = __commonJS({
         enforcement_state,
         inescapable_deploy: false,
         residuals: [],
-        detail
+        detail: detailOf(receipt),
+        verification
       });
       if (!target.environment || String(target.environment).trim() === "" || !target.artifact_id || String(target.artifact_id).trim() === "") {
         return deny(allowPending ? "pending" : "failure", "inputs_incomplete");
       }
+      const tokenInput = input.token;
+      if (tokenInput && typeof tokenInput.token === "string" && tokenInput.token.length > 0) {
+        const tv = (0, deploy_receipt_token_js_1.verifyDeployReceiptToken)(tokenInput, {
+          operation: opRequired,
+          environment: target.environment,
+          artifact_id: target.artifact_id
+        });
+        verification = { mode: "token", verify_status: tv.status };
+        if (tv.denyReason) {
+          receipt = tv.view;
+          return deny("failure", tv.denyReason);
+        }
+        receipt = tv.view;
+      } else if (receipt === null || receipt === void 0) {
+        return deny(allowPending ? "pending" : "failure", "no_receipt");
+      } else if (isVerifiedDeployReceiptView(receipt)) {
+        verification = {
+          mode: "verified_view",
+          verify_status: typeof receipt.verify_status === "string" ? receipt.verify_status : null
+        };
+      } else {
+        verification = { mode: "unverified", verify_status: null };
+        return deny("failure", "unverified_receipt_view");
+      }
       if (receipt === null || receipt === void 0) {
         return deny(allowPending ? "pending" : "failure", "no_receipt");
       }
@@ -70056,7 +72458,8 @@ var require_deploy_gate = __commonJS({
         inescapable_deploy,
         residuals,
         ...residual ? { residual } : {},
-        detail
+        detail: detailOf(receipt),
+        verification
       };
     }
   }
@@ -70078,7 +72481,12 @@ var require_deploy_bind = __commonJS({
       "fingerprint_mismatch",
       "body_hash_mismatch",
       "no_receipt",
-      "inputs_incomplete"
+      "inputs_incomplete",
+      "unverified_receipt_view",
+      "invalid_signature",
+      "expired",
+      "unknown_key",
+      "retired_key"
     ]);
     exports2.DEPLOY_REPAIRABLE_REASONS = REPAIRABLE;
     function asHostAssertedEnvironment(env) {
@@ -70111,6 +72519,7 @@ var require_deploy_bind = __commonJS({
       const gate = (0, deploy_gate_js_1.deployGate)({
         deployTarget,
         receipt: input.receipt,
+        token: input.token,
         requiredContext,
         ...input.allowPending != null ? { allowPending: input.allowPending } : {},
         ...input.allowWarnDeploy != null ? { allowWarnDeploy: input.allowWarnDeploy } : {},
@@ -70362,6 +72771,8 @@ var require_with_coderifts = __commonJS({
       }
       if (input.requireConditionalWrite === false)
         flags.push("requireConditionalWrite");
+      if (input.requireCommitObservation === false)
+        flags.push("requireCommitObservation");
       const reg = input.registry ?? {};
       if (reg.failOnUnguardedMutator === false)
         flags.push("failOnUnguardedMutator");
@@ -70582,6 +72993,18 @@ var require_with_coderifts = __commonJS({
       if (input.monitoringSinkWired !== void 0) {
         guard.monitoringSinkWired = input.monitoringSinkWired;
       }
+      if (input.monitoringSink !== void 0) {
+        guard.monitoringSink = input.monitoringSink;
+      }
+      if (input.monitoringSinkTimeoutMs !== void 0) {
+        guard.monitoringSinkTimeoutMs = input.monitoringSinkTimeoutMs;
+      }
+      if (input.ackHmacKey !== void 0) {
+        guard.ackHmacKey = input.ackHmacKey;
+      }
+      if (input.profile === "ENFORCING_STRICT") {
+        guard.profile = "ENFORCING_STRICT";
+      }
       if (hostPreviousReceipt !== void 0 || threadReceipts) {
         guard.previousReceipt = () => {
           if (hostPreviousReceipt !== void 0) {
@@ -70605,11 +73028,24 @@ var require_with_coderifts = __commonJS({
       if (input.requireExecutionStateMatch !== void 0) {
         guard.requireExecutionStateMatch = input.requireExecutionStateMatch;
       }
+      if (input.requireCommitObservation !== void 0) {
+        guard.requireCommitObservation = input.requireCommitObservation;
+      }
+      if (input.autoRecheck !== void 0) {
+        guard.autoRecheck = input.autoRecheck;
+      }
+      if (input.autoDerive !== void 0) {
+        guard.autoDerive = input.autoDerive;
+      }
+      if (input.executorAttestation !== void 0) {
+        guard.executorAttestation = input.executorAttestation;
+      }
       const strict = isEnforcingStrict(input);
       if (strict) {
         guard.requireFreshness = true;
         guard.requireConditionalWrite = true;
         guard.requireExecutionStateMatch = true;
+        guard.requireCommitObservation = true;
       }
       const config = {
         guard,
@@ -70753,7 +73189,7 @@ var require_openai = __commonJS({
         const kind = outcome.verdict && typeof outcome.verdict === "object" && "kind" in outcome.verdict ? String(outcome.verdict.kind) : "UNKNOWN";
         body = `Tool execution failed after gate decision (verdict: ${kind}): ${errText}`;
       }
-      const content = (0, final_answer_proof_js_1.attachProofToAgentResponse)(body, outcome.proof);
+      const content = args.attachProof === false ? body : (0, final_answer_proof_js_1.attachProofToAgentResponse)(body, outcome.proof);
       const msg = {
         role: "tool",
         tool_call_id,
@@ -70851,7 +73287,7 @@ var require_anthropic = __commonJS({
         const kind = verdictKind(outcome);
         body = `Tool execution failed after gate decision (verdict: ${kind}): ${formatGuardError(err)}`;
       }
-      const content = (0, final_answer_proof_js_1.attachProofToAgentResponse)(body, outcome.proof);
+      const content = args.attachProof === false ? body : (0, final_answer_proof_js_1.attachProofToAgentResponse)(body, outcome.proof);
       const block = {
         type: "tool_result",
         tool_use_id,
@@ -70955,7 +73391,7 @@ var require_langgraph = __commonJS({
         const kind = verdictKind(outcome);
         body = `Tool execution failed after gate decision (verdict: ${kind}): ${formatGuardError(err)}`;
       }
-      const content = (0, final_answer_proof_js_1.attachProofToAgentResponse)(body, outcome.proof);
+      const content = args.attachProof === false ? body : (0, final_answer_proof_js_1.attachProofToAgentResponse)(body, outcome.proof);
       const msg = {
         content,
         tool_call_id
@@ -71070,7 +73506,7 @@ var require_gemini = __commonJS({
           gate_message: `Tool execution failed after gate decision (verdict: ${kind}): ${formatGuardError(err)}`
         };
       }
-      const bound = (0, final_answer_proof_js_1.attachProofToAgentResponse)(base, outcome.proof);
+      const bound = args.attachProof === false ? base : (0, final_answer_proof_js_1.attachProofToAgentResponse)(base, outcome.proof);
       const part = {
         functionResponse: {
           name,
@@ -71149,6 +73585,13 @@ var require_execute_tool_call = __commonJS({
       require_conditional_write: false,
       write_style: false
     });
+    function notObserved() {
+      return {
+        status: "not_observed",
+        observed_at: (/* @__PURE__ */ new Date()).toISOString(),
+        host_attestation: "absent"
+      };
+    }
     function unknownToolOutcome(toolName) {
       const verdict = {
         kind: "UNAVAILABLE",
@@ -71159,12 +73602,14 @@ var require_execute_tool_call = __commonJS({
         decisionMissing: true,
         unavailableCount: 1
       };
+      const commit_observation = notObserved();
       const proof = (0, execution_proof_js_1.buildExecutionProof)({
         preflighted: false,
         executionAttempted: false,
         executed: false,
         enforced: false,
-        verdict
+        verdict,
+        commitObservation: commit_observation
       });
       void toolName;
       return {
@@ -71175,7 +73620,8 @@ var require_execute_tool_call = __commonJS({
         preflighted: false,
         proof,
         freshness: FRESHNESS_NOT_CONFIGURED,
-        conditional_write: CW_NOT_REPORTED
+        conditional_write: CW_NOT_REPORTED,
+        commit_observation
       };
     }
     function wrapRawAsOutcome(result) {
@@ -71185,13 +73631,15 @@ var require_execute_tool_call = __commonJS({
         signals: ["dispatcher_passthrough"],
         detectorVersion: "execute-tool-call"
       };
+      const commit_observation = notObserved();
       const proof = (0, execution_proof_js_1.buildExecutionProof)({
         preflighted: false,
         executionAttempted: true,
         executed: true,
         enforced: false,
         verdict,
-        result
+        result,
+        commitObservation: commit_observation
       });
       return {
         executionAttempted: true,
@@ -71202,7 +73650,8 @@ var require_execute_tool_call = __commonJS({
         preflighted: false,
         proof,
         freshness: FRESHNESS_NOT_CONFIGURED,
-        conditional_write: CW_NOT_REPORTED
+        conditional_write: CW_NOT_REPORTED,
+        commit_observation
       };
     }
     function wrapThrownAsOutcome(error) {
@@ -71212,13 +73661,15 @@ var require_execute_tool_call = __commonJS({
         signals: ["dispatcher_passthrough_throw"],
         detectorVersion: "execute-tool-call"
       };
+      const commit_observation = notObserved();
       const proof = (0, execution_proof_js_1.buildExecutionProof)({
         preflighted: false,
         executionAttempted: true,
         executed: false,
         enforced: false,
         verdict,
-        error
+        error,
+        commitObservation: commit_observation
       });
       return {
         executionAttempted: true,
@@ -71229,7 +73680,8 @@ var require_execute_tool_call = __commonJS({
         preflighted: false,
         proof,
         freshness: FRESHNESS_NOT_CONFIGURED,
-        conditional_write: CW_NOT_REPORTED
+        conditional_write: CW_NOT_REPORTED,
+        commit_observation
       };
     }
     async function executeProtectedTool(table, toolName, args) {
@@ -71373,13 +73825,14 @@ var require_execute_tool_call = __commonJS({
 });
 
 // node_modules/@coderifts/agent-guard/dist/cjs/index.js
-var require_cjs3 = __commonJS({
+var require_cjs4 = __commonJS({
   "node_modules/@coderifts/agent-guard/dist/cjs/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.RESIDUAL_UNCONDITIONAL_WRITE = exports2.conditionalWriteResidual = exports2.tokensEqual = exports2.buildConditionalWriteBasis = exports2.buildFreshnessBasis = exports2.collectFreshnessCallContext = exports2.artifactIdsForResolve = exports2.isWriteStyleCall = exports2.freshnessAllowsEnforce = exports2.computePathSetTreeHash = exports2.contentByteIdentical = exports2.assessWriteStylePrior = exports2.assessFreshness = exports2.deriveProofBanner = exports2.attachProofToAgentResponse = exports2.renderFinalAnswerProof = exports2.EXECUTION_PROOF_SPEC = exports2.assertEnforcedReceiptInvariant = exports2.hashExecutionResult = exports2.buildExecutionProof = 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.EXECUTION_TIME_FP_REASONS = exports2.EXECUTION_STATE_UNMEASURABLE_NOTE = exports2.isUnmeasurableExecutionStateReason = exports2.computeCanonicalBundleFingerprint = exports2.authorizedFingerprintFromEnvelope = exports2.checkExecutionTimeFingerprint = exports2.computeBundleFingerprint = exports2.computeArtifactDigest = exports2.evaluateEnvelope = exports2.RECEIPT_PREV_NULL = exports2.decodeReceiptBodyPrev = exports2.previousReceiptCommitment = exports2.verifyReceiptChainLinkage = exports2.canonicalJson = exports2.computeBodyHash = exports2.bindReceiptToEnvelope = exports2.DETECTOR_VERSION = exports2.builtinDetector = exports2.guardToolCall = void 0;
-    exports2.openAIToolAdapter = exports2.withCodeRiftsOpenAI = exports2.guardedFractionAmongRoutes = exports2.foldTableSettledCalls = exports2.withCodeRifts = exports2.coverageReport = exports2.DEPLOY_REPAIRABLE_REASONS = exports2.bindDeploy = exports2.deployGate = exports2.gateDecision = exports2.RegistryConstructionError = exports2.guardToolRegistry = exports2.globToRegExp = exports2.matchGlob = exports2.blobMapKey = exports2.classifyByName = exports2.resolveArtifacts = exports2.REMEDIATION_LOOP_ATTESTATION_SPEC = exports2.isCasAttestation = exports2.readPriorBlockRemediation = exports2.readRemediationTransaction = exports2.buildRemediationLoopAttestation = exports2.CAS_ATTESTATION_SPEC = exports2.isExecuteIfUnchangedOutcome = exports2.isGuardExecutionProof = exports2.buildCasAttestation = exports2.REGISTRY_ABSENT_TOKEN = exports2.REGISTRY_VERSION_TOKEN_PREFIX = exports2.registryTokenRaw = exports2.writeRegistryIfUnchanged = exports2.createRegistryVersionToken = exports2.DB_ABSENT_TOKEN = exports2.DB_VERSION_TOKEN_PREFIX = exports2.dbTokenRaw = exports2.writeDbIfUnchanged = exports2.createDbVersionToken = exports2.API_ABSENT_TOKEN = exports2.API_VERSION_TOKEN_PREFIX = exports2.apiTokenRaw = exports2.writeApiIfUnchanged = exports2.createApiVersionToken = exports2.FS_ABSENT_TOKEN = exports2.FS_VERSION_TOKEN_PREFIX = exports2.fsTokenContentHash = exports2.createFsPriorContentResolver = exports2.writeFileIfUnchanged = exports2.readVersionedFile = exports2.createFsVersionToken = exports2.StaleVersionTokenAbort = exports2.executeIfUnchanged = void 0;
-    exports2.surfaceEnvelopeFields = exports2.isGuardOutcome = exports2.executeLangGraphToolCall = exports2.executeGeminiToolCall = exports2.executeAnthropicToolCall = exports2.executeOpenAIToolCall = exports2.executeProtectedTool = exports2.defaultSerializeGeminiToolResult = exports2.bindGeminiGuardOutcome = exports2.protectedToolToFunctionDeclaration = exports2.toGeminiTools = exports2.geminiToolAdapter = exports2.withCodeRiftsGemini = exports2.defaultSerializeLangGraphToolResult = exports2.bindLangGraphGuardOutcome = exports2.protectedToolToLangGraph = exports2.toLangGraphTools = exports2.langGraphToolAdapter = exports2.withCodeRiftsLangGraph = exports2.defaultSerializeAnthropicToolResult = exports2.bindAnthropicGuardOutcome = exports2.protectedToolToAnthropic = exports2.toAnthropicTools = exports2.anthropicToolAdapter = exports2.withCodeRiftsAnthropic = exports2.defaultSerializeOpenAIToolResult = exports2.bindOpenAIGuardOutcome = exports2.protectedToolToOpenAI = exports2.toOpenAITools = void 0;
+    exports2.freshnessAllowsEnforce = exports2.computePathSetTreeHash = exports2.contentByteIdentical = exports2.assessWriteStylePrior = exports2.assessFreshness = exports2.deriveProofBanner = exports2.attachProofToAgentResponse = exports2.renderFinalAnswerProof = exports2.EXECUTION_PROOF_SPEC = exports2.assertEnforcedReceiptInvariant = exports2.hashExecutionResult = exports2.buildExecutionProof = exports2.DEFAULT_MONITORING_SINK_TIMEOUT_MS = exports2.ackBytes = exports2.verifyAckHmac = exports2.monitoringDeliveryFailClosed = exports2.formatMonitoringDeliveryLine = exports2.deliverMonitoring = exports2.hashObservedContent = exports2.observeCommit = 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.EXECUTION_TIME_FP_REASONS = exports2.EXECUTION_STATE_UNMEASURABLE_NOTE = exports2.isUnmeasurableExecutionStateReason = exports2.computeCanonicalBundleFingerprint = exports2.authorizedFingerprintFromEnvelope = exports2.checkExecutionTimeFingerprint = exports2.computeBundleFingerprint = exports2.computeArtifactDigest = exports2.evaluateEnvelope = exports2.RECEIPT_PREV_NULL = exports2.decodeReceiptBodyPrev = exports2.previousReceiptCommitment = exports2.verifyReceiptChainLinkage = exports2.canonicalJson = exports2.computeBodyHash = exports2.bindReceiptToEnvelope = exports2.DETECTOR_VERSION = exports2.builtinDetector = exports2.guardToolCall = void 0;
+    exports2.RegistryConstructionError = exports2.guardToolRegistry = exports2.globToRegExp = exports2.matchGlob = exports2.blobMapKey = exports2.classifyByName = exports2.resolveArtifacts = exports2.REMEDIATION_LOOP_ATTESTATION_SPEC = exports2.isCasAttestation = exports2.readPriorBlockRemediation = exports2.readRemediationTransaction = exports2.buildRemediationLoopAttestation = exports2.CAS_ATTESTATION_SPEC = exports2.extractExecutorAttestationToken = exports2.evaluateCasEvidence = exports2.isExecuteIfUnchangedOutcome = exports2.isGuardExecutionProof = exports2.buildCasAttestation = exports2.REGISTRY_ABSENT_TOKEN = exports2.REGISTRY_VERSION_TOKEN_PREFIX = exports2.registryTokenRaw = exports2.writeRegistryIfUnchanged = exports2.createRegistryVersionToken = exports2.DB_ABSENT_TOKEN = exports2.DB_VERSION_TOKEN_PREFIX = exports2.dbTokenRaw = exports2.writeDbIfUnchanged = exports2.createDbVersionToken = exports2.API_ABSENT_TOKEN = exports2.API_VERSION_TOKEN_PREFIX = exports2.apiTokenRaw = exports2.writeApiIfUnchanged = exports2.createApiVersionToken = exports2.FS_ABSENT_TOKEN = exports2.FS_VERSION_TOKEN_PREFIX = exports2.fsTokenContentHash = exports2.createFsPriorContentResolver = exports2.writeFileIfUnchanged = exports2.readVersionedFile = exports2.createFsVersionToken = exports2.StaleVersionTokenAbort = exports2.executeIfUnchanged = exports2.RESIDUAL_UNCONDITIONAL_WRITE = exports2.conditionalWriteResidual = exports2.tokensEqual = exports2.buildConditionalWriteBasis = exports2.buildFreshnessBasis = exports2.collectFreshnessCallContext = exports2.artifactIdsForResolve = exports2.isWriteStyleCall = void 0;
+    exports2.executeLangGraphToolCall = exports2.executeGeminiToolCall = exports2.executeAnthropicToolCall = exports2.executeOpenAIToolCall = exports2.executeProtectedTool = exports2.defaultSerializeGeminiToolResult = exports2.bindGeminiGuardOutcome = exports2.protectedToolToFunctionDeclaration = exports2.toGeminiTools = exports2.geminiToolAdapter = exports2.withCodeRiftsGemini = exports2.defaultSerializeLangGraphToolResult = exports2.bindLangGraphGuardOutcome = exports2.protectedToolToLangGraph = exports2.toLangGraphTools = exports2.langGraphToolAdapter = exports2.withCodeRiftsLangGraph = exports2.defaultSerializeAnthropicToolResult = exports2.bindAnthropicGuardOutcome = exports2.protectedToolToAnthropic = exports2.toAnthropicTools = exports2.anthropicToolAdapter = exports2.withCodeRiftsAnthropic = exports2.defaultSerializeOpenAIToolResult = exports2.bindOpenAIGuardOutcome = exports2.protectedToolToOpenAI = exports2.toOpenAITools = exports2.openAIToolAdapter = exports2.withCodeRiftsOpenAI = exports2.guardedFractionAmongRoutes = exports2.foldTableSettledCalls = exports2.withCodeRifts = exports2.AUTO_DERIVE_READ_TIMEOUT_MS = exports2.AUTO_DERIVE_SOURCE = exports2.defaultFsReader = exports2.normalizeAutoDerive = exports2.runAutoDerive = exports2.AUTO_RECHECK_MAX_CAP = exports2.clampMaxAttempts = exports2.normalizeAutoRecheck = exports2.runAutoRecheckLoop = exports2.coverageReport = exports2.DEPLOY_REPAIRABLE_REASONS = exports2.bindDeploy = exports2.verifyDeployReceiptToken = exports2.DEPLOY_RECEIPT_VIEW_SPEC = exports2.isVerifiedDeployReceiptView = exports2.asVerifiedDeployReceiptView = exports2.deployGate = exports2.gateDecision = void 0;
+    exports2.surfaceEnvelopeFields = exports2.isGuardOutcome = void 0;
     var guard_js_1 = require_guard();
     Object.defineProperty(exports2, "guardToolCall", { enumerable: true, get: function() {
       return guard_js_1.guardToolCall;
@@ -71478,6 +73931,32 @@ var require_cjs3 = __commonJS({
     Object.defineProperty(exports2, "deriveKeySignal", { enumerable: true, get: function() {
       return session_taint_js_1.deriveKeySignal;
     } });
+    var commit_observation_js_1 = require_commit_observation();
+    Object.defineProperty(exports2, "observeCommit", { enumerable: true, get: function() {
+      return commit_observation_js_1.observeCommit;
+    } });
+    Object.defineProperty(exports2, "hashObservedContent", { enumerable: true, get: function() {
+      return commit_observation_js_1.hashObservedContent;
+    } });
+    var monitoring_delivery_js_1 = require_monitoring_delivery();
+    Object.defineProperty(exports2, "deliverMonitoring", { enumerable: true, get: function() {
+      return monitoring_delivery_js_1.deliverMonitoring;
+    } });
+    Object.defineProperty(exports2, "formatMonitoringDeliveryLine", { enumerable: true, get: function() {
+      return monitoring_delivery_js_1.formatMonitoringDeliveryLine;
+    } });
+    Object.defineProperty(exports2, "monitoringDeliveryFailClosed", { enumerable: true, get: function() {
+      return monitoring_delivery_js_1.monitoringDeliveryFailClosed;
+    } });
+    Object.defineProperty(exports2, "verifyAckHmac", { enumerable: true, get: function() {
+      return monitoring_delivery_js_1.verifyAckHmac;
+    } });
+    Object.defineProperty(exports2, "ackBytes", { enumerable: true, get: function() {
+      return monitoring_delivery_js_1.ackBytes;
+    } });
+    Object.defineProperty(exports2, "DEFAULT_MONITORING_SINK_TIMEOUT_MS", { enumerable: true, get: function() {
+      return monitoring_delivery_js_1.DEFAULT_MONITORING_SINK_TIMEOUT_MS;
+    } });
     var execution_proof_js_1 = require_execution_proof();
     Object.defineProperty(exports2, "buildExecutionProof", { enumerable: true, get: function() {
       return execution_proof_js_1.buildExecutionProof;
@@ -71628,6 +74107,12 @@ var require_cjs3 = __commonJS({
     Object.defineProperty(exports2, "isExecuteIfUnchangedOutcome", { enumerable: true, get: function() {
       return cas_attestation_js_1.isExecuteIfUnchangedOutcome;
     } });
+    Object.defineProperty(exports2, "evaluateCasEvidence", { enumerable: true, get: function() {
+      return cas_attestation_js_1.evaluateCasEvidence;
+    } });
+    Object.defineProperty(exports2, "extractExecutorAttestationToken", { enumerable: true, get: function() {
+      return cas_attestation_js_1.extractExecutorAttestationToken;
+    } });
     Object.defineProperty(exports2, "CAS_ATTESTATION_SPEC", { enumerable: true, get: function() {
       return cas_attestation_js_1.CAS_ATTESTATION_SPEC;
     } });
@@ -71679,6 +74164,19 @@ var require_cjs3 = __commonJS({
     Object.defineProperty(exports2, "deployGate", { enumerable: true, get: function() {
       return deploy_gate_js_1.deployGate;
     } });
+    Object.defineProperty(exports2, "asVerifiedDeployReceiptView", { enumerable: true, get: function() {
+      return deploy_gate_js_1.asVerifiedDeployReceiptView;
+    } });
+    Object.defineProperty(exports2, "isVerifiedDeployReceiptView", { enumerable: true, get: function() {
+      return deploy_gate_js_1.isVerifiedDeployReceiptView;
+    } });
+    Object.defineProperty(exports2, "DEPLOY_RECEIPT_VIEW_SPEC", { enumerable: true, get: function() {
+      return deploy_gate_js_1.DEPLOY_RECEIPT_VIEW_SPEC;
+    } });
+    var deploy_receipt_token_js_1 = require_deploy_receipt_token();
+    Object.defineProperty(exports2, "verifyDeployReceiptToken", { enumerable: true, get: function() {
+      return deploy_receipt_token_js_1.verifyDeployReceiptToken;
+    } });
     var deploy_bind_js_1 = require_deploy_bind();
     Object.defineProperty(exports2, "bindDeploy", { enumerable: true, get: function() {
       return deploy_bind_js_1.bindDeploy;
@@ -71690,6 +74188,35 @@ var require_cjs3 = __commonJS({
     Object.defineProperty(exports2, "coverageReport", { enumerable: true, get: function() {
       return coverage_report_js_1.coverageReport;
     } });
+    var auto_recheck_js_1 = require_auto_recheck();
+    Object.defineProperty(exports2, "runAutoRecheckLoop", { enumerable: true, get: function() {
+      return auto_recheck_js_1.runAutoRecheckLoop;
+    } });
+    Object.defineProperty(exports2, "normalizeAutoRecheck", { enumerable: true, get: function() {
+      return auto_recheck_js_1.normalizeAutoRecheck;
+    } });
+    Object.defineProperty(exports2, "clampMaxAttempts", { enumerable: true, get: function() {
+      return auto_recheck_js_1.clampMaxAttempts;
+    } });
+    Object.defineProperty(exports2, "AUTO_RECHECK_MAX_CAP", { enumerable: true, get: function() {
+      return auto_recheck_js_1.AUTO_RECHECK_MAX_CAP;
+    } });
+    var auto_derive_js_1 = require_auto_derive();
+    Object.defineProperty(exports2, "runAutoDerive", { enumerable: true, get: function() {
+      return auto_derive_js_1.runAutoDerive;
+    } });
+    Object.defineProperty(exports2, "normalizeAutoDerive", { enumerable: true, get: function() {
+      return auto_derive_js_1.normalizeAutoDerive;
+    } });
+    Object.defineProperty(exports2, "defaultFsReader", { enumerable: true, get: function() {
+      return auto_derive_js_1.defaultFsReader;
+    } });
+    Object.defineProperty(exports2, "AUTO_DERIVE_SOURCE", { enumerable: true, get: function() {
+      return auto_derive_js_1.AUTO_DERIVE_SOURCE;
+    } });
+    Object.defineProperty(exports2, "AUTO_DERIVE_READ_TIMEOUT_MS", { enumerable: true, get: function() {
+      return auto_derive_js_1.AUTO_DERIVE_READ_TIMEOUT_MS;
+    } });
     var with_coderifts_js_1 = require_with_coderifts();
     Object.defineProperty(exports2, "withCodeRifts", { enumerable: true, get: function() {
       return with_coderifts_js_1.withCodeRifts;
@@ -74681,7 +77208,7 @@ var require_names2 = __commonJS({
 });
 
 // ../../node_modules/ajv/dist/compile/errors.js
-var require_errors5 = __commonJS({
+var require_errors6 = __commonJS({
   "../../node_modules/ajv/dist/compile/errors.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -74808,7 +77335,7 @@ var require_boolSchema2 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.boolOrEmptySchema = exports2.topBoolOrEmptySchema = void 0;
-    var errors_1 = require_errors5();
+    var errors_1 = require_errors6();
     var codegen_1 = require_codegen2();
     var names_1 = require_names2();
     var boolError = {
@@ -74915,7 +77442,7 @@ var require_dataType2 = __commonJS({
     exports2.reportTypeError = exports2.checkDataTypes = exports2.checkDataType = exports2.coerceAndCheckDataType = exports2.getJSONTypes = exports2.getSchemaTypes = exports2.DataType = void 0;
     var rules_1 = require_rules2();
     var applicability_1 = require_applicability2();
-    var errors_1 = require_errors5();
+    var errors_1 = require_errors6();
     var codegen_1 = require_codegen2();
     var util_1 = require_util5();
     var DataType;
@@ -75270,7 +77797,7 @@ var require_keyword2 = __commonJS({
     var codegen_1 = require_codegen2();
     var names_1 = require_names2();
     var code_1 = require_code4();
-    var errors_1 = require_errors5();
+    var errors_1 = require_errors6();
     function macroKeywordCode(cxt, def) {
       const { gen, keyword, schema, parentSchema, it } = cxt;
       const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
@@ -75758,7 +78285,7 @@ var require_validate2 = __commonJS({
     var names_1 = require_names2();
     var resolve_1 = require_resolve2();
     var util_1 = require_util5();
-    var errors_1 = require_errors5();
+    var errors_1 = require_errors6();
     function validateFunctionCode(it) {
       if (isSchemaObj(it)) {
         checkKeywords(it);
@@ -87820,7 +90347,7 @@ var require_lib6 = __commonJS({
 });
 
 // ../../node_modules/pg/lib/client.js
-var require_client = __commonJS({
+var require_client2 = __commonJS({
   "../../node_modules/pg/lib/client.js"(exports2, module2) {
     var EventEmitter = require("events").EventEmitter;
     var utils = require_utils4();
@@ -89005,7 +91532,7 @@ var require_query2 = __commonJS({
 });
 
 // ../../node_modules/pg/lib/native/client.js
-var require_client2 = __commonJS({
+var require_client3 = __commonJS({
   "../../node_modules/pg/lib/native/client.js"(exports2, module2) {
     var nodeUtils = require("util");
     var Native;
@@ -89261,7 +91788,7 @@ var require_client2 = __commonJS({
 var require_native = __commonJS({
   "../../node_modules/pg/lib/native/index.js"(exports2, module2) {
     "use strict";
-    module2.exports = require_client2();
+    module2.exports = require_client3();
   }
 });
 
@@ -89269,7 +91796,7 @@ var require_native = __commonJS({
 var require_lib7 = __commonJS({
   "../../node_modules/pg/lib/index.js"(exports2, module2) {
     "use strict";
-    var Client = require_client();
+    var Client = require_client2();
     var defaults = require_defaults4();
     var Connection = require_connection();
     var Result = require_result();
@@ -89349,7 +91876,7 @@ var require_verbatim_string = __commonJS({
 });
 
 // ../../node_modules/@redis/client/dist/lib/errors.js
-var require_errors6 = __commonJS({
+var require_errors7 = __commonJS({
   "../../node_modules/@redis/client/dist/lib/errors.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -89468,7 +91995,7 @@ var require_decoder = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.Decoder = exports2.PUSH_TYPE_MAPPING = exports2.RESP_TYPES = void 0;
     var verbatim_string_1 = require_verbatim_string();
-    var errors_1 = require_errors6();
+    var errors_1 = require_errors7();
     exports2.RESP_TYPES = {
       NULL: 95,
       // _
@@ -103679,7 +106206,7 @@ var require_socket = __commonJS({
     var node_events_1 = require("node:events");
     var node_net_1 = __importDefault(require("node:net"));
     var node_tls_1 = __importDefault(require("node:tls"));
-    var errors_1 = require_errors6();
+    var errors_1 = require_errors7();
     var promises_1 = require("node:timers/promises");
     var enterprise_maintenance_manager_1 = require_enterprise_maintenance_manager();
     var RedisSocket = class extends node_events_1.EventEmitter {
@@ -105124,7 +107651,7 @@ var require_commands_queue = __commonJS({
     var encoder_1 = __importDefault(require_encoder());
     var decoder_1 = require_decoder();
     var pub_sub_1 = require_pub_sub();
-    var errors_1 = require_errors6();
+    var errors_1 = require_errors7();
     var enterprise_maintenance_manager_1 = require_enterprise_maintenance_manager();
     var PONG = Buffer.from("pong");
     var RESET = Buffer.from("RESET");
@@ -105673,7 +108200,7 @@ var require_multi_command = __commonJS({
   "../../node_modules/@redis/client/dist/lib/multi-command.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    var errors_1 = require_errors6();
+    var errors_1 = require_errors7();
     var RedisMultiCommand = class {
       typeMapping;
       constructor(typeMapping) {
@@ -106562,10 +109089,10 @@ var require_pool = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.RedisClientPool = void 0;
     var commands_1 = require_commands();
-    var _1 = __importDefault(require_client3());
+    var _1 = __importDefault(require_client4());
     var node_events_1 = require("node:events");
     var linked_list_1 = require_linked_list();
-    var errors_1 = require_errors6();
+    var errors_1 = require_errors7();
     var commander_1 = require_commander2();
     var multi_command_1 = __importDefault(require_multi_command2());
     var cache_1 = require_cache();
@@ -106924,7 +109451,7 @@ var require_package2 = __commonJS({
 });
 
 // ../../node_modules/@redis/client/dist/lib/client/index.js
-var require_client3 = __commonJS({
+var require_client4 = __commonJS({
   "../../node_modules/@redis/client/dist/lib/client/index.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
@@ -106965,7 +109492,7 @@ var require_client3 = __commonJS({
     var commands_queue_1 = __importDefault(require_commands_queue());
     var node_events_1 = require("node:events");
     var commander_1 = require_commander2();
-    var errors_1 = require_errors6();
+    var errors_1 = require_errors7();
     var node_url_1 = require("node:url");
     var pub_sub_1 = require_pub_sub();
     var multi_command_1 = __importDefault(require_multi_command2());
@@ -107895,8 +110422,8 @@ var require_cluster_slots = __commonJS({
     var _a;
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.RESUBSCRIBE_LISTENERS_EVENT = void 0;
-    var errors_1 = require_errors6();
-    var client_1 = __importDefault(require_client3());
+    var errors_1 = require_errors7();
+    var client_1 = __importDefault(require_client4());
     var pub_sub_1 = require_pub_sub();
     var cluster_key_slot_1 = __importDefault(require_lib8());
     var cache_1 = require_cache();
@@ -108633,7 +111160,7 @@ var require_cluster = __commonJS({
     var commander_1 = require_commander2();
     var cluster_slots_1 = __importStar(require_cluster_slots());
     var multi_command_1 = __importDefault(require_multi_command3());
-    var errors_1 = require_errors6();
+    var errors_1 = require_errors7();
     var parser_1 = require_parser2();
     var ASKING_1 = require_ASKING();
     var single_entry_cache_1 = __importDefault(require_single_entry_cache());
@@ -109192,7 +111719,7 @@ var require_pub_sub_proxy = __commonJS({
     exports2.PubSubProxy = void 0;
     var node_events_1 = __importDefault(require("node:events"));
     var pub_sub_1 = require_pub_sub();
-    var client_1 = __importDefault(require_client3());
+    var client_1 = __importDefault(require_client4());
     var PubSubProxy = class extends node_events_1.default {
       #clientOptions;
       #onError;
@@ -109527,7 +112054,7 @@ var require_sentinel = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.RedisSentinelFactory = exports2.RedisSentinelClient = void 0;
     var node_events_1 = require("node:events");
-    var client_1 = __importDefault(require_client3());
+    var client_1 = __importDefault(require_client4());
     var commander_1 = require_commander2();
     var commands_1 = require_commands();
     var utils_1 = require_utils6();
@@ -110702,8 +113229,8 @@ var require_dist3 = __commonJS({
     Object.defineProperty(exports2, "digest", { enumerable: true, get: function() {
       return digest_1.digest;
     } });
-    __exportStar(require_errors6(), exports2);
-    var client_1 = __importDefault(require_client3());
+    __exportStar(require_errors7(), exports2);
+    var client_1 = __importDefault(require_client4());
     exports2.createClient = client_1.default.create;
     var pool_1 = require_pool();
     exports2.createClientPool = pool_1.RedisClientPool.create;
@@ -141040,7 +143567,7 @@ var require_util6 = __commonJS({
 });
 
 // ../../node_modules/zod/v4/core/errors.cjs
-var require_errors7 = __commonJS({
+var require_errors8 = __commonJS({
   "../../node_modules/zod/v4/core/errors.cjs"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
@@ -141250,7 +143777,7 @@ var require_parse4 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.safeDecodeAsync = exports2._safeDecodeAsync = exports2.safeEncodeAsync = exports2._safeEncodeAsync = exports2.safeDecode = exports2._safeDecode = exports2.safeEncode = exports2._safeEncode = exports2.decodeAsync = exports2._decodeAsync = exports2.encodeAsync = exports2._encodeAsync = exports2.decode = exports2._decode = exports2.encode = exports2._encode = exports2.safeParseAsync = exports2._safeParseAsync = exports2.safeParse = exports2._safeParse = exports2.parseAsync = exports2._parseAsync = exports2.parse = exports2._parse = void 0;
     var core = __importStar(require_core7());
-    var errors = __importStar(require_errors7());
+    var errors = __importStar(require_errors8());
     var util = __importStar(require_util6());
     var _parse = (_Err) => (schema, value, _ctx, _params) => {
       const ctx = _ctx ? Object.assign(_ctx, { async: false }) : { async: false };
@@ -153956,7 +156483,7 @@ var require_core8 = __commonJS({
     exports2.JSONSchema = exports2.JSONSchemaGenerator = exports2.toJSONSchema = exports2.locales = exports2.regexes = exports2.util = void 0;
     __exportStar(require_core7(), exports2);
     __exportStar(require_parse4(), exports2);
-    __exportStar(require_errors7(), exports2);
+    __exportStar(require_errors8(), exports2);
     __exportStar(require_schemas(), exports2);
     __exportStar(require_checks(), exports2);
     __exportStar(require_versions(), exports2);
@@ -154147,7 +156674,7 @@ var require_iso = __commonJS({
 });
 
 // ../../node_modules/zod/v4/classic/errors.cjs
-var require_errors8 = __commonJS({
+var require_errors9 = __commonJS({
   "../../node_modules/zod/v4/classic/errors.cjs"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
@@ -154257,7 +156784,7 @@ var require_parse5 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.safeDecodeAsync = exports2.safeEncodeAsync = exports2.safeDecode = exports2.safeEncode = exports2.decodeAsync = exports2.encodeAsync = exports2.decode = exports2.encode = exports2.safeParseAsync = exports2.safeParse = exports2.parseAsync = exports2.parse = void 0;
     var core = __importStar(require_core8());
-    var errors_js_1 = require_errors8();
+    var errors_js_1 = require_errors9();
     exports2.parse = core._parse(errors_js_1.ZodRealError);
     exports2.parseAsync = core._parseAsync(errors_js_1.ZodRealError);
     exports2.safeParse = core._safeParse(errors_js_1.ZodRealError);
@@ -156170,7 +158697,7 @@ var require_external = __commonJS({
     exports2.core = __importStar(require_core8());
     __exportStar(require_schemas2(), exports2);
     __exportStar(require_checks2(), exports2);
-    __exportStar(require_errors8(), exports2);
+    __exportStar(require_errors9(), exports2);
     __exportStar(require_parse5(), exports2);
     __exportStar(require_compat(), exports2);
     var index_js_1 = require_core8();
@@ -199750,7 +202277,7 @@ var require_clock_skew_leeway = __commonJS({
 });
 
 // ../../src/verdict-core/execution-grant.js
-var require_execution_grant = __commonJS({
+var require_execution_grant2 = __commonJS({
   "../../src/verdict-core/execution-grant.js"(exports2, module2) {
     "use strict";
     var crypto = require("node:crypto");
@@ -201021,7 +203548,7 @@ var require_change_set = __commonJS({
           const {
             issueExecutionGrant,
             afterPayloadCanonical
-          } = require_execution_grant();
+          } = require_execution_grant2();
           const grantTarget = nonEmptyStr(context.target_id) || artifactDigest;
           const stateNonce = typeof input.state_nonce === "string" && input.state_nonce.length > 0 ? input.state_nonce : null;
           executionGrant = issueExecutionGrant({
@@ -204890,7 +207417,11 @@ var require_deploy_gate2 = __commonJS({
     var fs = require("fs");
     var path = require("path");
     var chalk = require_source();
-    var { deployGate } = require_cjs3();
+    var {
+      deployGate,
+      asVerifiedDeployReceiptView,
+      DEPLOY_RECEIPT_VIEW_SPEC
+    } = require_cjs4();
     var { renderJson } = require_json2();
     var { renderDecisionWhy, isEnvFlag } = require_claude_hook();
     function loadVerifierKernel() {
@@ -204916,7 +207447,8 @@ var require_deploy_gate2 = __commonJS({
       "retired_key",
       "unknown_key",
       "receipt_context_required",
-      "target_mismatch"
+      "target_mismatch",
+      "unverified_receipt_view"
     ]);
     var DEFAULT_KEYS_URL = "https://app.coderifts.com/.well-known/coderifts-keys.json";
     var KEYS_FETCH_TIMEOUT_MS = 1e4;
@@ -204959,9 +207491,24 @@ var require_deploy_gate2 = __commonJS({
     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 }) {
+    function stampVerifiedView(receipt) {
+      if (!receipt || typeof receipt !== "object") return receipt;
+      if (receipt.view_spec === DEPLOY_RECEIPT_VIEW_SPEC && receipt.verified === true) return receipt;
+      const status = typeof receipt.verify_status === "string" ? receipt.verify_status : receipt.currently_authorized === true ? "VERIFIED_CURRENT" : "VERIFIED_EXPIRED";
+      return asVerifiedDeployReceiptView(receipt, status);
+    }
+    function deployBind({
+      environment,
+      artifact_id,
+      receipt,
+      token,
+      observed_cd_enforcement,
+      expected_fingerprint,
+      expected_body_hash
+    }) {
       const attested_enforcement = observed_cd_enforcement && observed_cd_enforcement.enforcement || "UNKNOWN";
-      if (!receipt) {
+      const hasToken = !!(token && typeof token.token === "string" && token.token.length > 0);
+      if (!hasToken && !receipt) {
         return {
           deploy_check_status: "pending",
           reason: "no_receipt",
@@ -204969,7 +207516,8 @@ var require_deploy_gate2 = __commonJS({
           attested_enforcement,
           gate: null,
           report_residuals: [],
-          coverage_deploy_input: deployCoverageInput(attested_enforcement, false)
+          coverage_deploy_input: deployCoverageInput(attested_enforcement, false),
+          verification: { mode: "none", verify_status: null }
         };
       }
       const requiredContext = {
@@ -204981,16 +207529,17 @@ var require_deploy_gate2 = __commonJS({
         }
       };
       let change_set_rebound = false;
-      if (attested_enforcement === "ENFORCING") {
-        if (expected_fingerprint != null) {
-          requiredContext.expected_fingerprint = expected_fingerprint;
-          change_set_rebound = true;
-        }
-        if (expected_body_hash != null) requiredContext.expected_body_hash = expected_body_hash;
+      if (expected_fingerprint != null) {
+        requiredContext.expected_fingerprint = expected_fingerprint;
+        if (attested_enforcement === "ENFORCING") change_set_rebound = true;
+      }
+      if (attested_enforcement === "ENFORCING" && expected_body_hash != null) {
+        requiredContext.expected_body_hash = expected_body_hash;
       }
-      const gate = deployGate({ deployTarget: { environment, artifact_id }, receipt, requiredContext });
+      const gate = hasToken ? deployGate({ deployTarget: { environment, artifact_id }, token, requiredContext }) : deployGate({ deployTarget: { environment, artifact_id }, receipt: stampVerifiedView(receipt), requiredContext });
       const enforcement_inescapable = attested_enforcement === "ENFORCING" && !!(observed_cd_enforcement && observed_cd_enforcement.bypass_possible === false);
       const inescapable_deploy = gate.inescapable_deploy === true && change_set_rebound === true;
+      const verification = gate.verification || { mode: hasToken ? "token" : "verified_view", verify_status: null };
       return {
         deploy_check_status: gate.state,
         reason: gate.reason,
@@ -204998,7 +207547,8 @@ var require_deploy_gate2 = __commonJS({
         attested_enforcement,
         gate: { deploy_allowed: gate.deploy_allowed, reason: gate.reason, inescapable_deploy },
         report_residuals: deployReportResiduals(gate.state, enforcement_inescapable, attested_enforcement, change_set_rebound),
-        coverage_deploy_input: deployCoverageInput(attested_enforcement, inescapable_deploy)
+        coverage_deploy_input: deployCoverageInput(attested_enforcement, inescapable_deploy),
+        verification
       };
     }
     function clampExit(deployCheckStatus, advisory) {
@@ -205157,6 +207707,22 @@ var require_deploy_gate2 = __commonJS({
       authz = applyRetiredKeyLiveRule(status, authz, intended);
       return { result, status, authz };
     }
+    function overlayTokenWhy(bind, kernel, untrusted, keysSource) {
+      const v = bind && bind.verification || {};
+      bind.verification_mode = v.mode || "token";
+      bind.verify_status = v.verify_status || kernel && kernel.status || null;
+      bind.currently_authorized = bind.deploy_check_status === "success";
+      bind.authz_reason = bind.reason;
+      bind.untrusted_currently_authorized_input = untrusted === true;
+      bind.keys_source = keysSource || null;
+      bind.kernel_verify_status = kernel && kernel.status ? kernel.status : null;
+      return bind;
+    }
+    function causesAgree(gateReason, kernelReason) {
+      if (gateReason === "allow_current_deploy") return kernelReason == null;
+      if (kernelReason == null) return false;
+      return gateReason === kernelReason;
+    }
     function reasonFromVerify({ status, authz, hasToken, hasEnvelope }) {
       if (!hasToken) return "unsigned_receipt";
       if (status === "INVALID_SIGNATURE") return "invalid_signature";
@@ -205176,21 +207742,6 @@ var require_deploy_gate2 = __commonJS({
       if (ar === "target_mismatch") return "stale_artifact";
       return ar;
     }
-    function verifiedReceiptView(envelope, payload, currentlyAuthorized) {
-      const artifact = envelope && (envelope.target_id || envelope.artifact_digest || envelope.bound_artifact_id);
-      return {
-        currently_authorized: currentlyAuthorized === true,
-        decision: envelope && envelope.decision,
-        execution_action: envelope && envelope.execution_action,
-        operation: envelope && envelope.operation,
-        bound_environment: envelope && envelope.environment,
-        bound_artifact_id: artifact,
-        decision_id: envelope && envelope.decision_id,
-        blocking_reasons: envelope && envelope.blocking_reasons,
-        decision_result: envelope,
-        fingerprint: envelope && envelope.fingerprint || payload && payload.fp || null
-      };
-    }
     function policyBlockBind({
       reason,
       verify_status,
@@ -205359,48 +207910,40 @@ var require_deploy_gate2 = __commonJS({
         target_id: artifactId,
         fingerprint: options.fingerprint || void 0
       };
-      const verified = verifyDeployReceipt({
+      const bind = deployBind({
+        environment,
+        artifact_id: artifactId,
+        token: {
+          token,
+          decision_result: envelope || void 0,
+          registry: keys.registry,
+          pinnedKeyPem: keys.pinnedKeyPem
+        },
+        observed_cd_enforcement: observed,
+        expected_fingerprint: options.fingerprint || void 0
+      });
+      const kernel = verifyDeployReceipt({
         token,
         envelope,
         intended,
         registry: keys.registry,
         pinnedKeyPem: keys.pinnedKeyPem
       });
-      const reason = reasonFromVerify({
-        status: verified.status,
-        authz: verified.authz,
-        hasToken: true,
-        hasEnvelope: !!envelope
-      });
-      const computedAuthorized = verified.authz && verified.authz.currently_authorized === true && verified.status === "VERIFIED_CURRENT";
-      if (reason || !computedAuthorized) {
-        const bind2 = policyBlockBind({
-          reason: reason || "receipt_not_authorized",
-          verify_status: verified.status,
-          currently_authorized: false,
-          authz_reason: verified.authz && verified.authz.authz_reason || reason || "receipt_not_authorized",
-          untrusted,
-          attested_enforcement: attested
-        });
-        return finish(bind2, {
-          failureClass: "policy",
-          retryable: false,
-          receiptForWhy: envelope ? { ...parsed, decision_result: envelope } : parsed
-        });
-      }
-      const view = verifiedReceiptView(envelope, verified.result.payload, true);
-      const bind = deployBind({
-        environment,
-        artifact_id: artifactId,
-        receipt: view,
-        observed_cd_enforcement: observed
+      overlayTokenWhy(bind, kernel, untrusted, keys.source);
+      bind.causes_agree = causesAgree(
+        bind.reason,
+        reasonFromVerify({
+          status: kernel.status,
+          authz: kernel.authz,
+          hasToken: true,
+          hasEnvelope: !!envelope
+        })
+      );
+      return finish(bind, {
+        failureClass: bind.deploy_check_status === "success" ? null : "policy",
+        retryable: false,
+        receiptForWhy: envelope ? { ...parsed, decision_result: envelope } : parsed
       });
-      bind.verify_status = verified.status;
-      bind.currently_authorized = true;
-      bind.authz_reason = verified.authz && verified.authz.authz_reason;
-      bind.untrusted_currently_authorized_input = untrusted;
-      bind.keys_source = keys.source || null;
-      return finish(bind, { failureClass: bind.deploy_check_status === "success" ? null : "policy", retryable: false, receiptForWhy: view });
     }
     module2.exports = {
       runDeployGate,
@@ -205413,6 +207956,10 @@ var require_deploy_gate2 = __commonJS({
       extractDecisionEnvelope,
       loadKeysMaterial,
       verifyDeployReceipt,
+      stampVerifiedView,
+      overlayTokenWhy,
+      causesAgree,
+      reasonFromVerify,
       extractDecisionIdFromReceipt,
       formatOutcomeReportHint,
       renderDeployGateTerminal,
@@ -206153,7 +208700,7 @@ var require_registry_gate = __commonJS({
     var fs = require("fs");
     var path = require("path");
     var chalk = require_source();
-    var { matchGlob } = require_cjs3();
+    var { matchGlob } = require_cjs4();
     var {
       validateRegistry,
       safeParse,
@@ -217173,7 +219720,7 @@ var require_zipWith = __commonJS({
 });
 
 // node_modules/rxjs/dist/cjs/index.js
-var require_cjs4 = __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) {
@@ -218490,7 +221037,7 @@ var require_run_async = __commonJS({
 var require_utils11 = __commonJS({
   "node_modules/inquirer/lib/utils/utils.js"(exports2) {
     "use strict";
-    var { from, of } = require_cjs4();
+    var { from, of } = require_cjs5();
     var runAsync = require_run_async();
     exports2.fetchAsyncQuestionProperty = function(question, prop, answers) {
       if (typeof question[prop] !== "function") {
@@ -218515,7 +221062,7 @@ var require_prompt = __commonJS({
       get: require_get3(),
       set: require_set4()
     };
-    var { defer, empty, from, of } = require_cjs4();
+    var { defer, empty, from, of } = require_cjs5();
     var { concatMap, filter, publish, reduce } = require_operators();
     var runAsync = require_run_async();
     var utils = require_utils11();
@@ -221229,7 +223776,7 @@ var require_base = __commonJS({
 var require_events = __commonJS({
   "node_modules/inquirer/lib/utils/events.js"(exports2, module2) {
     "use strict";
-    var { fromEvent } = require_cjs4();
+    var { fromEvent } = require_cjs5();
     var { filter, map, share, takeUntil } = require_operators();
     function normalizeKeypressEvents(value, key) {
       return { value, key: key || {} };
@@ -232027,7 +234574,7 @@ var require_editor = __commonJS({
     var { editAsync } = require_commonjs();
     var Base = require_base();
     var observe = require_events();
-    var { Subject } = require_cjs4();
+    var { Subject } = require_cjs5();
     var EditorPrompt = class extends Base {
       /**
        * Start the Inquiry session