motebit 1.4.2 → 1.4.3

package/dist/index.js

@@ -982,6 +982,7 @@ var init_audience = __esm({
       "task:submit",
       "admin:query",
       "proposal",
+      "receipts:read",
       "account:balance",
       "account:deposit",
       "account:withdraw",
@@ -8061,6 +8062,7 @@ async function* runTurnStreaming(deps, userMessage, options) {
   let iteration = 0;
   let toolCallsSucceeded = 0;
   let toolCallsBlocked = 0;
+  let toolCallsDenied = 0;
   let toolCallsFailed = 0;
   const toolResultsLog = [];
   let lastToolName = "";
@@ -8154,6 +8156,7 @@ async function* runTurnStreaming(deps, userMessage, options) {
         const decision = deps.policyGate.validate(toolDef, toolCall.args, turnCtx);
         if (!decision.allowed) {
           toolCallsBlocked++;
+          toolCallsDenied++;
           yield {
             type: "tool_status",
             name: toolCall.name,
@@ -8591,6 +8594,7 @@ ${correction}`;
       iterations: iteration,
       toolCallsSucceeded,
       toolCallsBlocked,
+      toolCallsDenied,
       toolCallsFailed,
       ...turnCtx && turnCtx.costAccumulated > 0 ? { totalTokens: turnCtx.costAccumulated } : {}
     }
@@ -8638,6 +8642,7 @@ var dist_exports2 = {};
 __export(dist_exports2, {
   ADJUDICATOR_VOTE_SUITE: () => ADJUDICATOR_VOTE_SUITE,
   AGENT_SETTLEMENT_ANCHOR_SUITE: () => AGENT_SETTLEMENT_ANCHOR_SUITE,
+  APPROVAL_DECISION_SUITE: () => APPROVAL_DECISION_SUITE,
   BALANCE_WAIVER_SUITE: () => BALANCE_WAIVER_SUITE,
   COLLABORATIVE_RECEIPT_SUITE: () => COLLABORATIVE_RECEIPT_SUITE,
   COMPUTER_SESSION_RECEIPT_SUITE: () => COMPUTER_SESSION_RECEIPT_SUITE,
@@ -8709,6 +8714,7 @@ __export(dist_exports2, {
   resolveTreeHashVersion: () => resolveTreeHashVersion,
   sha256: () => sha2562,
   signAdjudicatorVote: () => signAdjudicatorVote,
+  signApprovalDecision: () => signApprovalDecision,
   signBalanceWaiver: () => signBalanceWaiver,
   signBySuite: () => signBySuite,
   signCertAsDelegate: () => signCertAsDelegate,
@@ -8747,6 +8753,7 @@ __export(dist_exports2, {
   verify: () => verify,
   verifyAdjudicatorVote: () => verifyAdjudicatorVote,
   verifyAgentSettlementAnchor: () => verifyAgentSettlementAnchor,
+  verifyApprovalDecision: () => verifyApprovalDecision,
   verifyBalanceWaiver: () => verifyBalanceWaiver,
   verifyBySuite: () => verifyBySuite,
   verifyCollaborativeReceipt: () => verifyCollaborativeReceipt,
@@ -11970,387 +11977,6 @@ async function verifyMerkleInclusion(leaf, index, siblings, layerSizes, expected
   }
   return toHex(current) === expectedRoot;
 }
-function signatureWithoutValue(sig) {
-  return { suite: sig.suite, public_key: sig.public_key };
-}
-function canonicalizeSkillManifestBytes(manifest, body) {
-  const motebitForCanonical = manifest.motebit.signature ? {
-    ...manifest.motebit,
-    signature: signatureWithoutValue(manifest.motebit.signature)
-  } : manifest.motebit;
-  const manifestForCanonical = { ...manifest, motebit: motebitForCanonical };
-  const canonical = canonicalJson(manifestForCanonical);
-  const manifestBytes = new TextEncoder().encode(canonical);
-  const out = new Uint8Array(manifestBytes.length + 1 + body.length);
-  out.set(manifestBytes, 0);
-  out[manifestBytes.length] = 10;
-  out.set(body, manifestBytes.length + 1);
-  return out;
-}
-function canonicalizeSkillEnvelopeBytes(envelope) {
-  const envelopeForCanonical = {
-    ...envelope,
-    signature: signatureWithoutValue(envelope.signature)
-  };
-  const canonical = canonicalJson(envelopeForCanonical);
-  return new TextEncoder().encode(canonical);
-}
-async function signSkillManifest(unsigned, privateKey, publicKey, body) {
-  const publicKeyHex = bytesToLowerHex(publicKey);
-  const unsignedWithSig = {
-    ...unsigned,
-    motebit: {
-      ...unsigned.motebit,
-      signature: {
-        suite: SKILL_SIGNATURE_SUITE,
-        public_key: publicKeyHex,
-        value: ""
-        // placeholder; stripped by canonicalize
-      }
-    }
-  };
-  const message2 = canonicalizeSkillManifestBytes(unsignedWithSig, body);
-  const sig = await signBySuite(SKILL_SIGNATURE_SUITE, message2, privateKey);
-  return {
-    ...unsigned,
-    motebit: {
-      ...unsigned.motebit,
-      signature: {
-        suite: SKILL_SIGNATURE_SUITE,
-        public_key: publicKeyHex,
-        value: toBase64Url(sig)
-      }
-    }
-  };
-}
-async function signSkillEnvelope(unsigned, privateKey, publicKey) {
-  const publicKeyHex = bytesToLowerHex(publicKey);
-  const unsignedWithSig = {
-    ...unsigned,
-    signature: {
-      suite: SKILL_SIGNATURE_SUITE,
-      public_key: publicKeyHex,
-      value: ""
-      // placeholder; stripped by canonicalize
-    }
-  };
-  const message2 = canonicalizeSkillEnvelopeBytes(unsignedWithSig);
-  const sig = await signBySuite(SKILL_SIGNATURE_SUITE, message2, privateKey);
-  return {
-    ...unsigned,
-    signature: {
-      suite: SKILL_SIGNATURE_SUITE,
-      public_key: publicKeyHex,
-      value: toBase64Url(sig)
-    }
-  };
-}
-async function verifySkillManifest(manifest, body, publicKey) {
-  return (await verifySkillManifestDetailed(manifest, body, publicKey)).valid;
-}
-async function verifySkillManifestDetailed(manifest, body, publicKey) {
-  const sig = manifest.motebit.signature;
-  if (!sig) return { valid: false, reason: "no_signature" };
-  if (sig.suite !== SKILL_SIGNATURE_SUITE) return { valid: false, reason: "wrong_suite" };
-  const publicKeyHex = bytesToLowerHex(publicKey);
-  if (sig.public_key.toLowerCase() !== publicKeyHex) {
-    return { valid: false, reason: "bad_public_key" };
-  }
-  let sigBytes;
-  try {
-    sigBytes = fromBase64Url(sig.value);
-  } catch {
-    return { valid: false, reason: "bad_signature_value" };
-  }
-  const message2 = canonicalizeSkillManifestBytes(manifest, body);
-  const valid = await verifyBySuite(SKILL_SIGNATURE_SUITE, message2, sigBytes, publicKey);
-  return { valid, reason: valid ? "ok" : "ed25519_mismatch" };
-}
-async function verifySkillEnvelope(envelope, publicKey) {
-  return (await verifySkillEnvelopeDetailed(envelope, publicKey)).valid;
-}
-async function verifySkillEnvelopeDetailed(envelope, publicKey) {
-  const sig = envelope.signature;
-  if (sig.suite !== SKILL_SIGNATURE_SUITE) return { valid: false, reason: "wrong_suite" };
-  const publicKeyHex = bytesToLowerHex(publicKey);
-  if (sig.public_key.toLowerCase() !== publicKeyHex) {
-    return { valid: false, reason: "bad_public_key" };
-  }
-  let sigBytes;
-  try {
-    sigBytes = fromBase64Url(sig.value);
-  } catch {
-    return { valid: false, reason: "bad_signature_value" };
-  }
-  const message2 = canonicalizeSkillEnvelopeBytes(envelope);
-  const valid = await verifyBySuite(SKILL_SIGNATURE_SUITE, message2, sigBytes, publicKey);
-  return { valid, reason: valid ? "ok" : "ed25519_mismatch" };
-}
-function bytesToLowerHex(bytes) {
-  let hex = "";
-  for (const b3 of bytes) {
-    hex += b3.toString(16).padStart(2, "0");
-  }
-  return hex;
-}
-function decodeSkillSignaturePublicKey(sig) {
-  return hexToBytes5(sig.public_key);
-}
-function verifyHardwareAttestationClaim(claim, expectedIdentityPublicKeyHex, verifiers, deviceCheckContext) {
-  const platform = claim.platform;
-  const errors = [];
-  switch (platform) {
-    case "secure_enclave":
-      return verifySecureEnclaveClaim(claim, expectedIdentityPublicKeyHex);
-    case "software":
-      errors.push({
-        message: "platform `software` is a no-hardware sentinel; no verification channel"
-      });
-      return { valid: false, platform: "software", errors };
-    case "device_check":
-      if (verifiers?.deviceCheck) {
-        return dispatchInjected(
-          platform,
-          verifiers.deviceCheck(claim, expectedIdentityPublicKeyHex, deviceCheckContext)
-        );
-      }
-      errors.push({
-        message: `platform \`${platform}\` verifier not wired \u2014 pass { deviceCheck: deviceCheckVerifier(...) } from @motebit/crypto-appattest to enable`
-      });
-      return { valid: false, platform, errors };
-    case "tpm":
-      if (verifiers?.tpm) {
-        return dispatchInjected(
-          platform,
-          verifiers.tpm(claim, expectedIdentityPublicKeyHex, deviceCheckContext)
-        );
-      }
-      errors.push({
-        message: `platform \`${platform}\` verifier not wired \u2014 pass { tpm: ... } via the verifiers parameter to enable`
-      });
-      return { valid: false, platform, errors };
-    case "play_integrity":
-      if (verifiers?.playIntegrity) {
-        return dispatchInjected(
-          platform,
-          verifiers.playIntegrity(claim, expectedIdentityPublicKeyHex, deviceCheckContext)
-        );
-      }
-      errors.push({
-        message: `platform \`${platform}\` verifier not wired \u2014 pass { playIntegrity: ... } via the verifiers parameter to enable`
-      });
-      return { valid: false, platform, errors };
-    case "webauthn":
-      if (verifiers?.webauthn) {
-        return dispatchInjected(
-          platform,
-          verifiers.webauthn(claim, expectedIdentityPublicKeyHex, deviceCheckContext)
-        );
-      }
-      errors.push({
-        message: `platform \`${platform}\` verifier not wired \u2014 pass { webauthn: webauthnVerifier(...) } from @motebit/crypto-webauthn to enable`
-      });
-      return { valid: false, platform, errors };
-    case "android_keystore":
-      if (verifiers?.androidKeystore) {
-        return dispatchInjected(
-          platform,
-          verifiers.androidKeystore(claim, expectedIdentityPublicKeyHex, deviceCheckContext)
-        );
-      }
-      errors.push({
-        message: `platform \`${platform}\` verifier not wired \u2014 pass { androidKeystore: androidKeystoreVerifier(...) } from @motebit/crypto-android-keystore to enable`
-      });
-      return { valid: false, platform, errors };
-    default:
-      errors.push({
-        message: `unknown platform \`${claim.platform}\` \u2014 not in the declared enum`
-      });
-      return { valid: false, platform: null, errors };
-  }
-}
-async function dispatchInjected(platform, result) {
-  const awaited = await Promise.resolve(result);
-  return {
-    valid: awaited.valid,
-    platform,
-    errors: awaited.errors ?? []
-  };
-}
-function verifySecureEnclaveClaim(claim, expectedIdentityPublicKeyHex) {
-  const errors = [];
-  const platform = "secure_enclave";
-  if (claim.key_exported === true) {
-  }
-  if (!claim.attestation_receipt) {
-    errors.push({
-      message: "secure_enclave claim missing `attestation_receipt`"
-    });
-    return { valid: false, platform, errors };
-  }
-  const parts = claim.attestation_receipt.split(".");
-  if (parts.length !== 2) {
-    errors.push({
-      message: `attestation_receipt must be 2 base64url parts separated by '.'; got ${parts.length}`
-    });
-    return { valid: false, platform, errors };
-  }
-  const [bodyB64, sigB64] = parts;
-  let bodyBytes;
-  let sigBytes;
-  try {
-    bodyBytes = fromBase64Url(bodyB64);
-    sigBytes = fromBase64Url(sigB64);
-  } catch (err2) {
-    errors.push({
-      message: `base64url decode failed: ${err2 instanceof Error ? err2.message : String(err2)}`
-    });
-    return { valid: false, platform, errors };
-  }
-  let bodyJson;
-  try {
-    bodyJson = JSON.parse(new TextDecoder().decode(bodyBytes));
-  } catch (err2) {
-    errors.push({
-      message: `body JSON parse failed: ${err2 instanceof Error ? err2.message : String(err2)}`
-    });
-    return { valid: false, platform, errors };
-  }
-  const bodyCheck = parseSecureEnclaveBody(bodyJson);
-  if (bodyCheck.kind === "error") {
-    errors.push({ message: bodyCheck.reason });
-    return { valid: false, platform, errors };
-  }
-  const body = bodyCheck.body;
-  if (body.version !== "1") {
-    errors.push({
-      message: `unsupported body version '${body.version}' (expected '1')`
-    });
-    return { valid: false, platform, errors };
-  }
-  if (body.algorithm !== "ecdsa-p256-sha256") {
-    errors.push({
-      message: `unsupported body algorithm '${body.algorithm}' (expected 'ecdsa-p256-sha256')`
-    });
-    return { valid: false, platform, errors };
-  }
-  let sigValid;
-  try {
-    sigValid = verifyP256EcdsaSha256(body.se_public_key, bodyBytes, sigBytes);
-  } catch (err2) {
-    errors.push({
-      message: `p-256 verification crashed: ${err2 instanceof Error ? err2.message : String(err2)}`
-    });
-    return { valid: false, platform, errors };
-  }
-  if (!sigValid) {
-    errors.push({
-      message: "p-256 signature does not verify against body + se_public_key"
-    });
-    return { valid: false, platform, errors };
-  }
-  if (body.identity_public_key.toLowerCase() !== expectedIdentityPublicKeyHex.toLowerCase()) {
-    errors.push({
-      message: `identity_public_key mismatch: body names ${body.identity_public_key.slice(0, 16)}\u2026, expected ${expectedIdentityPublicKeyHex.slice(0, 16)}\u2026`
-    });
-    return { valid: false, platform, errors };
-  }
-  return {
-    valid: true,
-    platform,
-    se_public_key: body.se_public_key,
-    attested_at: body.attested_at,
-    errors: []
-  };
-}
-function parseSecureEnclaveBody(raw) {
-  if (raw === null || typeof raw !== "object") {
-    return { kind: "error", reason: "body is not a JSON object" };
-  }
-  const r2 = raw;
-  const fields = [
-    "version",
-    "algorithm",
-    "motebit_id",
-    "device_id",
-    "identity_public_key",
-    "se_public_key",
-    "attested_at"
-  ];
-  for (const f6 of fields) {
-    if (!(f6 in r2)) {
-      return { kind: "error", reason: `body missing required field '${f6}'` };
-    }
-  }
-  if (typeof r2.version !== "string" || typeof r2.algorithm !== "string" || typeof r2.motebit_id !== "string" || typeof r2.device_id !== "string" || typeof r2.identity_public_key !== "string" || typeof r2.se_public_key !== "string" || typeof r2.attested_at !== "number") {
-    return { kind: "error", reason: "body field types invalid" };
-  }
-  return {
-    kind: "ok",
-    body: {
-      version: r2.version,
-      algorithm: r2.algorithm,
-      motebit_id: r2.motebit_id,
-      device_id: r2.device_id,
-      identity_public_key: r2.identity_public_key,
-      se_public_key: r2.se_public_key,
-      attested_at: r2.attested_at
-    }
-  };
-}
-function encodeSecureEnclaveReceiptForTest(bodyBytes, sigBytes) {
-  return `${toBase64Url2(bodyBytes)}.${toBase64Url2(sigBytes)}`;
-}
-function canonicalSecureEnclaveBodyForTest(body) {
-  const full = {
-    version: "1",
-    algorithm: "ecdsa-p256-sha256",
-    ...body
-  };
-  return new TextEncoder().encode(canonicalJson(full));
-}
-async function mintSecureEnclaveReceiptForTest(input) {
-  const { p256: p2562 } = await Promise.resolve().then(() => (init_nist(), nist_exports));
-  const privateKey = p2562.utils.randomSecretKey();
-  const sePublicKey = p2562.getPublicKey(privateKey, true);
-  const sePublicKeyHex = bytesToHexLocal(sePublicKey);
-  const bodyBytes = canonicalSecureEnclaveBodyForTest({
-    motebit_id: input.motebit_id,
-    device_id: input.device_id,
-    identity_public_key: input.identity_public_key,
-    se_public_key: sePublicKeyHex,
-    attested_at: input.attested_at
-  });
-  const digest = await sha256Local(bodyBytes);
-  const sigBytes = p2562.sign(digest, privateKey, { prehash: false, format: "der" });
-  const receipt = encodeSecureEnclaveReceiptForTest(bodyBytes, sigBytes);
-  return {
-    claim: {
-      platform: "secure_enclave",
-      key_exported: false,
-      attestation_receipt: receipt
-    },
-    sePublicKeyHex
-  };
-}
-function bytesToHexLocal(bytes) {
-  let hex = "";
-  for (let i3 = 0; i3 < bytes.length; i3++) {
-    hex += bytes[i3].toString(16).padStart(2, "0");
-  }
-  return hex;
-}
-async function sha256Local(bytes) {
-  const buf = await crypto.subtle.digest("SHA-256", bytes);
-  return new Uint8Array(buf);
-}
-function toBase64Url2(bytes) {
-  let binary = "";
-  for (let i3 = 0; i3 < bytes.length; i3++) {
-    binary += String.fromCharCode(bytes[i3]);
-  }
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
 function isReceiptDebugEnabled() {
   const g3 = globalThis;
   if (g3.__motebit_debug_receipt_bytes === true) return true;
@@ -12677,6 +12303,27 @@ async function verifyAdjudicatorVote(vote, peerPublicKey) {
     return false;
   }
 }
+async function signApprovalDecision(decision, approverPrivateKey, publicKey) {
+  const withKey = publicKey ? { ...decision, public_key: bytesToHex4(publicKey) } : decision;
+  const body = { ...withKey, suite: APPROVAL_DECISION_SUITE };
+  const canonical = canonicalJson(body);
+  const message2 = new TextEncoder().encode(canonical);
+  const sig = await signBySuite(APPROVAL_DECISION_SUITE, message2, approverPrivateKey);
+  const signed = { ...body, signature: toBase64Url(sig) };
+  return Object.freeze(signed);
+}
+async function verifyApprovalDecision(decision, approverPublicKey) {
+  if (decision.suite !== APPROVAL_DECISION_SUITE) return false;
+  const { signature, ...body } = decision;
+  const canonical = canonicalJson(body);
+  const message2 = new TextEncoder().encode(canonical);
+  try {
+    const sig = fromBase64Url(signature);
+    return await verifyBySuite(decision.suite, message2, sig, approverPublicKey);
+  } catch {
+    return false;
+  }
+}
 async function signDisputeResolution(resolution, adjudicatorPrivateKey) {
   const body = { ...resolution, suite: DISPUTE_RESOLUTION_SUITE };
   const canonical = canonicalJson(body);
@@ -13227,6 +12874,387 @@ async function signCredentialBundle(bundle, privateKey) {
   );
   return { ...withHash, signature: toBase64Url(sig) };
 }
+function signatureWithoutValue(sig) {
+  return { suite: sig.suite, public_key: sig.public_key };
+}
+function canonicalizeSkillManifestBytes(manifest, body) {
+  const motebitForCanonical = manifest.motebit.signature ? {
+    ...manifest.motebit,
+    signature: signatureWithoutValue(manifest.motebit.signature)
+  } : manifest.motebit;
+  const manifestForCanonical = { ...manifest, motebit: motebitForCanonical };
+  const canonical = canonicalJson(manifestForCanonical);
+  const manifestBytes = new TextEncoder().encode(canonical);
+  const out = new Uint8Array(manifestBytes.length + 1 + body.length);
+  out.set(manifestBytes, 0);
+  out[manifestBytes.length] = 10;
+  out.set(body, manifestBytes.length + 1);
+  return out;
+}
+function canonicalizeSkillEnvelopeBytes(envelope) {
+  const envelopeForCanonical = {
+    ...envelope,
+    signature: signatureWithoutValue(envelope.signature)
+  };
+  const canonical = canonicalJson(envelopeForCanonical);
+  return new TextEncoder().encode(canonical);
+}
+async function signSkillManifest(unsigned, privateKey, publicKey, body) {
+  const publicKeyHex = bytesToLowerHex(publicKey);
+  const unsignedWithSig = {
+    ...unsigned,
+    motebit: {
+      ...unsigned.motebit,
+      signature: {
+        suite: SKILL_SIGNATURE_SUITE,
+        public_key: publicKeyHex,
+        value: ""
+        // placeholder; stripped by canonicalize
+      }
+    }
+  };
+  const message2 = canonicalizeSkillManifestBytes(unsignedWithSig, body);
+  const sig = await signBySuite(SKILL_SIGNATURE_SUITE, message2, privateKey);
+  return {
+    ...unsigned,
+    motebit: {
+      ...unsigned.motebit,
+      signature: {
+        suite: SKILL_SIGNATURE_SUITE,
+        public_key: publicKeyHex,
+        value: toBase64Url(sig)
+      }
+    }
+  };
+}
+async function signSkillEnvelope(unsigned, privateKey, publicKey) {
+  const publicKeyHex = bytesToLowerHex(publicKey);
+  const unsignedWithSig = {
+    ...unsigned,
+    signature: {
+      suite: SKILL_SIGNATURE_SUITE,
+      public_key: publicKeyHex,
+      value: ""
+      // placeholder; stripped by canonicalize
+    }
+  };
+  const message2 = canonicalizeSkillEnvelopeBytes(unsignedWithSig);
+  const sig = await signBySuite(SKILL_SIGNATURE_SUITE, message2, privateKey);
+  return {
+    ...unsigned,
+    signature: {
+      suite: SKILL_SIGNATURE_SUITE,
+      public_key: publicKeyHex,
+      value: toBase64Url(sig)
+    }
+  };
+}
+async function verifySkillManifest(manifest, body, publicKey) {
+  return (await verifySkillManifestDetailed(manifest, body, publicKey)).valid;
+}
+async function verifySkillManifestDetailed(manifest, body, publicKey) {
+  const sig = manifest.motebit.signature;
+  if (!sig) return { valid: false, reason: "no_signature" };
+  if (sig.suite !== SKILL_SIGNATURE_SUITE) return { valid: false, reason: "wrong_suite" };
+  const publicKeyHex = bytesToLowerHex(publicKey);
+  if (sig.public_key.toLowerCase() !== publicKeyHex) {
+    return { valid: false, reason: "bad_public_key" };
+  }
+  let sigBytes;
+  try {
+    sigBytes = fromBase64Url(sig.value);
+  } catch {
+    return { valid: false, reason: "bad_signature_value" };
+  }
+  const message2 = canonicalizeSkillManifestBytes(manifest, body);
+  const valid = await verifyBySuite(SKILL_SIGNATURE_SUITE, message2, sigBytes, publicKey);
+  return { valid, reason: valid ? "ok" : "ed25519_mismatch" };
+}
+async function verifySkillEnvelope(envelope, publicKey) {
+  return (await verifySkillEnvelopeDetailed(envelope, publicKey)).valid;
+}
+async function verifySkillEnvelopeDetailed(envelope, publicKey) {
+  const sig = envelope.signature;
+  if (sig.suite !== SKILL_SIGNATURE_SUITE) return { valid: false, reason: "wrong_suite" };
+  const publicKeyHex = bytesToLowerHex(publicKey);
+  if (sig.public_key.toLowerCase() !== publicKeyHex) {
+    return { valid: false, reason: "bad_public_key" };
+  }
+  let sigBytes;
+  try {
+    sigBytes = fromBase64Url(sig.value);
+  } catch {
+    return { valid: false, reason: "bad_signature_value" };
+  }
+  const message2 = canonicalizeSkillEnvelopeBytes(envelope);
+  const valid = await verifyBySuite(SKILL_SIGNATURE_SUITE, message2, sigBytes, publicKey);
+  return { valid, reason: valid ? "ok" : "ed25519_mismatch" };
+}
+function bytesToLowerHex(bytes) {
+  let hex = "";
+  for (const b3 of bytes) {
+    hex += b3.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function decodeSkillSignaturePublicKey(sig) {
+  return hexToBytes5(sig.public_key);
+}
+function verifyHardwareAttestationClaim(claim, expectedIdentityPublicKeyHex, verifiers, deviceCheckContext) {
+  const platform = claim.platform;
+  const errors = [];
+  switch (platform) {
+    case "secure_enclave":
+      return verifySecureEnclaveClaim(claim, expectedIdentityPublicKeyHex);
+    case "software":
+      errors.push({
+        message: "platform `software` is a no-hardware sentinel; no verification channel"
+      });
+      return { valid: false, platform: "software", errors };
+    case "device_check":
+      if (verifiers?.deviceCheck) {
+        return dispatchInjected(
+          platform,
+          verifiers.deviceCheck(claim, expectedIdentityPublicKeyHex, deviceCheckContext)
+        );
+      }
+      errors.push({
+        message: `platform \`${platform}\` verifier not wired \u2014 pass { deviceCheck: deviceCheckVerifier(...) } from @motebit/crypto-appattest to enable`
+      });
+      return { valid: false, platform, errors };
+    case "tpm":
+      if (verifiers?.tpm) {
+        return dispatchInjected(
+          platform,
+          verifiers.tpm(claim, expectedIdentityPublicKeyHex, deviceCheckContext)
+        );
+      }
+      errors.push({
+        message: `platform \`${platform}\` verifier not wired \u2014 pass { tpm: ... } via the verifiers parameter to enable`
+      });
+      return { valid: false, platform, errors };
+    case "play_integrity":
+      if (verifiers?.playIntegrity) {
+        return dispatchInjected(
+          platform,
+          verifiers.playIntegrity(claim, expectedIdentityPublicKeyHex, deviceCheckContext)
+        );
+      }
+      errors.push({
+        message: `platform \`${platform}\` verifier not wired \u2014 pass { playIntegrity: ... } via the verifiers parameter to enable`
+      });
+      return { valid: false, platform, errors };
+    case "webauthn":
+      if (verifiers?.webauthn) {
+        return dispatchInjected(
+          platform,
+          verifiers.webauthn(claim, expectedIdentityPublicKeyHex, deviceCheckContext)
+        );
+      }
+      errors.push({
+        message: `platform \`${platform}\` verifier not wired \u2014 pass { webauthn: webauthnVerifier(...) } from @motebit/crypto-webauthn to enable`
+      });
+      return { valid: false, platform, errors };
+    case "android_keystore":
+      if (verifiers?.androidKeystore) {
+        return dispatchInjected(
+          platform,
+          verifiers.androidKeystore(claim, expectedIdentityPublicKeyHex, deviceCheckContext)
+        );
+      }
+      errors.push({
+        message: `platform \`${platform}\` verifier not wired \u2014 pass { androidKeystore: androidKeystoreVerifier(...) } from @motebit/crypto-android-keystore to enable`
+      });
+      return { valid: false, platform, errors };
+    default:
+      errors.push({
+        message: `unknown platform \`${claim.platform}\` \u2014 not in the declared enum`
+      });
+      return { valid: false, platform: null, errors };
+  }
+}
+async function dispatchInjected(platform, result) {
+  const awaited = await Promise.resolve(result);
+  return {
+    valid: awaited.valid,
+    platform,
+    errors: awaited.errors ?? []
+  };
+}
+function verifySecureEnclaveClaim(claim, expectedIdentityPublicKeyHex) {
+  const errors = [];
+  const platform = "secure_enclave";
+  if (claim.key_exported === true) {
+  }
+  if (!claim.attestation_receipt) {
+    errors.push({
+      message: "secure_enclave claim missing `attestation_receipt`"
+    });
+    return { valid: false, platform, errors };
+  }
+  const parts = claim.attestation_receipt.split(".");
+  if (parts.length !== 2) {
+    errors.push({
+      message: `attestation_receipt must be 2 base64url parts separated by '.'; got ${parts.length}`
+    });
+    return { valid: false, platform, errors };
+  }
+  const [bodyB64, sigB64] = parts;
+  let bodyBytes;
+  let sigBytes;
+  try {
+    bodyBytes = fromBase64Url(bodyB64);
+    sigBytes = fromBase64Url(sigB64);
+  } catch (err2) {
+    errors.push({
+      message: `base64url decode failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+    });
+    return { valid: false, platform, errors };
+  }
+  let bodyJson;
+  try {
+    bodyJson = JSON.parse(new TextDecoder().decode(bodyBytes));
+  } catch (err2) {
+    errors.push({
+      message: `body JSON parse failed: ${err2 instanceof Error ? err2.message : String(err2)}`
+    });
+    return { valid: false, platform, errors };
+  }
+  const bodyCheck = parseSecureEnclaveBody(bodyJson);
+  if (bodyCheck.kind === "error") {
+    errors.push({ message: bodyCheck.reason });
+    return { valid: false, platform, errors };
+  }
+  const body = bodyCheck.body;
+  if (body.version !== "1") {
+    errors.push({
+      message: `unsupported body version '${body.version}' (expected '1')`
+    });
+    return { valid: false, platform, errors };
+  }
+  if (body.algorithm !== "ecdsa-p256-sha256") {
+    errors.push({
+      message: `unsupported body algorithm '${body.algorithm}' (expected 'ecdsa-p256-sha256')`
+    });
+    return { valid: false, platform, errors };
+  }
+  let sigValid;
+  try {
+    sigValid = verifyP256EcdsaSha256(body.se_public_key, bodyBytes, sigBytes);
+  } catch (err2) {
+    errors.push({
+      message: `p-256 verification crashed: ${err2 instanceof Error ? err2.message : String(err2)}`
+    });
+    return { valid: false, platform, errors };
+  }
+  if (!sigValid) {
+    errors.push({
+      message: "p-256 signature does not verify against body + se_public_key"
+    });
+    return { valid: false, platform, errors };
+  }
+  if (body.identity_public_key.toLowerCase() !== expectedIdentityPublicKeyHex.toLowerCase()) {
+    errors.push({
+      message: `identity_public_key mismatch: body names ${body.identity_public_key.slice(0, 16)}\u2026, expected ${expectedIdentityPublicKeyHex.slice(0, 16)}\u2026`
+    });
+    return { valid: false, platform, errors };
+  }
+  return {
+    valid: true,
+    platform,
+    se_public_key: body.se_public_key,
+    attested_at: body.attested_at,
+    errors: []
+  };
+}
+function parseSecureEnclaveBody(raw) {
+  if (raw === null || typeof raw !== "object") {
+    return { kind: "error", reason: "body is not a JSON object" };
+  }
+  const r2 = raw;
+  const fields = [
+    "version",
+    "algorithm",
+    "motebit_id",
+    "device_id",
+    "identity_public_key",
+    "se_public_key",
+    "attested_at"
+  ];
+  for (const f6 of fields) {
+    if (!(f6 in r2)) {
+      return { kind: "error", reason: `body missing required field '${f6}'` };
+    }
+  }
+  if (typeof r2.version !== "string" || typeof r2.algorithm !== "string" || typeof r2.motebit_id !== "string" || typeof r2.device_id !== "string" || typeof r2.identity_public_key !== "string" || typeof r2.se_public_key !== "string" || typeof r2.attested_at !== "number") {
+    return { kind: "error", reason: "body field types invalid" };
+  }
+  return {
+    kind: "ok",
+    body: {
+      version: r2.version,
+      algorithm: r2.algorithm,
+      motebit_id: r2.motebit_id,
+      device_id: r2.device_id,
+      identity_public_key: r2.identity_public_key,
+      se_public_key: r2.se_public_key,
+      attested_at: r2.attested_at
+    }
+  };
+}
+function encodeSecureEnclaveReceiptForTest(bodyBytes, sigBytes) {
+  return `${toBase64Url2(bodyBytes)}.${toBase64Url2(sigBytes)}`;
+}
+function canonicalSecureEnclaveBodyForTest(body) {
+  const full = {
+    version: "1",
+    algorithm: "ecdsa-p256-sha256",
+    ...body
+  };
+  return new TextEncoder().encode(canonicalJson(full));
+}
+async function mintSecureEnclaveReceiptForTest(input) {
+  const { p256: p2562 } = await Promise.resolve().then(() => (init_nist(), nist_exports));
+  const privateKey = p2562.utils.randomSecretKey();
+  const sePublicKey = p2562.getPublicKey(privateKey, true);
+  const sePublicKeyHex = bytesToHexLocal(sePublicKey);
+  const bodyBytes = canonicalSecureEnclaveBodyForTest({
+    motebit_id: input.motebit_id,
+    device_id: input.device_id,
+    identity_public_key: input.identity_public_key,
+    se_public_key: sePublicKeyHex,
+    attested_at: input.attested_at
+  });
+  const digest = await sha256Local(bodyBytes);
+  const sigBytes = p2562.sign(digest, privateKey, { prehash: false, format: "der" });
+  const receipt = encodeSecureEnclaveReceiptForTest(bodyBytes, sigBytes);
+  return {
+    claim: {
+      platform: "secure_enclave",
+      key_exported: false,
+      attestation_receipt: receipt
+    },
+    sePublicKeyHex
+  };
+}
+function bytesToHexLocal(bytes) {
+  let hex = "";
+  for (let i3 = 0; i3 < bytes.length; i3++) {
+    hex += bytes[i3].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+async function sha256Local(bytes) {
+  const buf = await crypto.subtle.digest("SHA-256", bytes);
+  return new Uint8Array(buf);
+}
+function toBase64Url2(bytes) {
+  let binary = "";
+  for (let i3 = 0; i3 < bytes.length; i3++) {
+    binary += String.fromCharCode(bytes[i3]);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
 function buildVerificationMethod(publicKey) {
   const did = publicKeyToDidKey(publicKey);
   const fragment = did.slice("did:key:".length);
@@ -14508,6 +14536,9 @@ function detectArtifactType(artifact) {
   if ("credentialSubject" in obj && "issuer" in obj && "proof" in obj) {
     return "credential";
   }
+  if ("invocation_id" in obj && "tool_name" in obj && "motebit_id" in obj && "signature" in obj) {
+    return "tool-invocation";
+  }
   if ("task_id" in obj && "motebit_id" in obj && "signature" in obj && "prompt_hash" in obj) {
     return "receipt";
   }
@@ -14887,23 +14918,26 @@ async function verifyIdentityBindingAnchored(identity, signingKeyHex, atTimestam
 async function verifyReceiptSignature(receipt, publicKey) {
   const { signature, ...body } = receipt;
   if (!signature || signature.trim() === "") {
-    return { valid: false, error: "Receipt signature is empty" };
+    return { valid: false, error: "\xA711.2 violation: receipt signature is empty" };
   }
   let sig;
   try {
     sig = fromBase64Url2(signature);
   } catch {
-    return { valid: false, error: "Receipt signature is not valid base64url" };
+    return { valid: false, error: "\xA711.2 violation: receipt signature is not valid base64url" };
   }
   if (sig.length !== 64) {
-    return { valid: false, error: `Receipt signature must be 64 bytes, got ${sig.length}` };
+    return {
+      valid: false,
+      error: `\xA711.2 violation: receipt signature must be 64 bytes, got ${sig.length}`
+    };
   }
   const canonical = canonicalJson2(body);
   const message2 = new TextEncoder().encode(canonical);
   const valid = await verifyBySuite("motebit-jcs-ed25519-b64-v1", message2, sig, publicKey);
   return { valid };
 }
-async function verifyReceipt(receipt) {
+async function verifyReceipt(receipt, options) {
   let publicKey = null;
   let signerDid;
   if (receipt.public_key) {
@@ -14924,26 +14958,43 @@ async function verifyReceipt(receipt) {
       type: "receipt",
       valid: false,
       receipt,
-      errors: [{ message: "No embedded public_key \u2014 cannot verify without known keys" }],
+      errors: [
+        {
+          message: "\xA711.3 violation: No embedded public_key \u2014 cannot verify without known keys"
+        }
+      ],
       ...delegations2.length > 0 ? { delegations: delegations2 } : {}
     };
   }
   const sigResult = await verifyReceiptSignature(receipt, publicKey);
   const errors = [];
   if (!sigResult.valid) {
-    errors.push({ message: sigResult.error ?? "Receipt signature verification failed" });
+    errors.push({
+      message: sigResult.error ?? "\xA711.2 violation: Ed25519 signature did not verify"
+    });
   }
   const delegations = await verifyReceiptDelegations(receipt);
   const delegationErrors = delegations.filter((d4) => !d4.valid);
   for (const d4 of delegationErrors) {
     errors.push({
-      message: `Delegation ${d4.receipt?.task_id ?? "unknown"}: verification failed`,
+      message: `\xA711.5 violation: delegation ${d4.receipt?.task_id ?? "unknown"} verification failed`,
       path: `delegation_receipts`
     });
   }
+  let resultHashOk = true;
+  if (options?.strictHashBinding) {
+    const expected = await hash(new TextEncoder().encode(receipt.result));
+    resultHashOk = expected === receipt.result_hash;
+    if (!resultHashOk) {
+      errors.push({
+        message: "result_hash does not equal hex(SHA-256(result)) \u2014 receipt is not self-consistent (strict mode)",
+        path: "result_hash"
+      });
+    }
+  }
   return {
     type: "receipt",
-    valid: sigResult.valid && delegationErrors.length === 0,
+    valid: sigResult.valid && delegationErrors.length === 0 && resultHashOk,
     receipt,
     signer: signerDid,
     keySource: "embedded",
@@ -14951,6 +15002,39 @@ async function verifyReceipt(receipt) {
     ...errors.length > 0 ? { errors } : {}
   };
 }
+async function verifyToolInvocation(receipt) {
+  let publicKey = null;
+  let signerDid;
+  if (receipt.public_key) {
+    try {
+      publicKey = hexToBytes6(receipt.public_key);
+      if (publicKey.length === 32) {
+        signerDid = publicKeyToDidKey2(publicKey);
+      } else {
+        publicKey = null;
+      }
+    } catch {
+      publicKey = null;
+    }
+  }
+  if (!publicKey) {
+    return {
+      type: "tool-invocation",
+      valid: false,
+      toolInvocation: receipt,
+      errors: [{ message: "No embedded public_key \u2014 cannot verify without known keys" }]
+    };
+  }
+  const valid = await verifyToolInvocationReceipt(receipt, publicKey);
+  return {
+    type: "tool-invocation",
+    valid,
+    toolInvocation: receipt,
+    signer: signerDid,
+    keySource: "embedded",
+    ...valid ? {} : { errors: [{ message: "Ed25519 signature did not verify" }] }
+  };
+}
 async function verifyReceiptDelegations(receipt) {
   if (!receipt.delegation_receipts || receipt.delegation_receipts.length === 0) {
     return [];
@@ -15190,23 +15274,16 @@ async function verifyPresentation(vp, clockSkewSeconds = DEFAULT_CLOCK_SKEW_SECO
 async function verify(artifact, options) {
   const detected = detectArtifactType(artifact);
   if (detected === null) {
-    const fallbackType = options?.expectedType ?? "identity";
+    const expected = options?.expectedType;
     return {
-      type: fallbackType,
+      type: "unknown",
       valid: false,
-      ...fallbackType === "identity" ? { identity: null } : {},
-      ...fallbackType === "receipt" ? { receipt: null } : {},
-      ...fallbackType === "credential" ? { credential: null } : {},
-      ...fallbackType === "presentation" ? { presentation: null } : {},
-      ...fallbackType === "skill" ? {
-        envelope: null,
-        steps: {
-          envelope: { valid: false, reason: "wrong_suite" },
-          body_hash: null,
-          files: []
+      reason: "unrecognized_artifact_type",
+      errors: [
+        {
+          message: expected ? `Unrecognized artifact format (expected "${expected}")` : "Unrecognized artifact format"
         }
-      } : {},
-      errors: [{ message: "Unrecognized artifact format" }]
+      ]
     };
   }
   if (options?.expectedType && options.expectedType !== detected) {
@@ -15215,6 +15292,7 @@ async function verify(artifact, options) {
       valid: false,
       ...detected === "identity" ? { identity: null } : {},
       ...detected === "receipt" ? { receipt: null } : {},
+      ...detected === "tool-invocation" ? { toolInvocation: null } : {},
       ...detected === "credential" ? { credential: null } : {},
       ...detected === "presentation" ? { presentation: null } : {},
       ...detected === "skill" ? {
@@ -15237,6 +15315,7 @@ async function verify(artifact, options) {
         type: detected,
         valid: false,
         ...detected === "receipt" ? { receipt: null } : {},
+        ...detected === "tool-invocation" ? { toolInvocation: null } : {},
         ...detected === "credential" ? { credential: null } : {},
         ...detected === "presentation" ? { presentation: null } : {},
         ...detected === "skill" ? {
@@ -15255,7 +15334,9 @@ async function verify(artifact, options) {
     case "identity":
       return verifyIdentity(resolved);
     case "receipt":
-      return verifyReceipt(resolved);
+      return verifyReceipt(resolved, options);
+    case "tool-invocation":
+      return verifyToolInvocation(resolved);
     case "credential":
       return verifyCredential(
         resolved,
@@ -15272,7 +15353,7 @@ async function verify(artifact, options) {
       return verifySkillEnvelopeArtifact(resolved);
   }
 }
-var __defProp2, __getOwnPropNames2, __esm2, __export2, hasHexBuiltin, hexes, asciis, oidNist, init_utils, HashMD, SHA256_IV, SHA384_IV, SHA512_IV, init_md, U32_MASK64, _32n, shrSH, shrSL, rotrSH, rotrSL, rotrBH, rotrBL, add3L, add3H, add4L, add4H, add5L, add5H, init_u64, SHA256_K, SHA256_W, SHA2_32B, _SHA256, K512, SHA512_Kh, SHA512_Kl, SHA512_W_H, SHA512_W_L, SHA2_64B, _SHA512, _SHA384, sha256, sha512, sha384, init_sha2, abytes3, anumber2, bytesToHex3, concatBytes3, hexToBytes3, isBytes3, randomBytes3, _0n, _1n, isPosBig, bitMask, init_utils2, _0n2, _1n2, _2n, _3n, _4n, _5n, _7n, _8n, _9n, _16n, FIELD_FIELDS, FIELD_SQRT, _Field, init_modular, _0n3, _1n3, pointPrecomputes, pointWindowSizes, wNAF2, init_curve, init_fft, os2ip, _DST_scalar, init_hash_to_curve, validateSigners, validateCommitmentsNum, AggErr, init_frost, _DST_scalarBytes, init_oprf, _HMAC, hmac, init_hmac, divNearest, DERErr, DER, _0n4, _1n4, _2n2, _3n2, _4n2, init_weierstrass, nist_exports, p256_CURVE, p384_CURVE, p521_CURVE, p256_Point, p256, p256_hasher, p256_oprf, p256_FROST, p384_Point, p384, p384_hasher, p384_oprf, p521_Point, p521, p521_hasher, p521_oprf, init_nist, ed25519_CURVE, P, N, Gx, Gy, _a, _d, h, L, captureTrace, err, isBig, isStr, isBytes, abytes, u8n, u8fr, padh, bytesToHex, C, _ch, hexToBytes, cr, subtle, concatBytes, randomBytes, big, assertRange, M, P_MASK, modP, modN, invert, callHash, checkDigest, apoint, B256, Point, G, I, numTo32bLE, bytesToNumberLE, pow2, pow_2_252_3, RM1, uvRatio, modL_LE, sha512a, hash2extK, getExtendedPublicKeyAsync, getPublicKeyAsync, hashFinishA, _sign, signAsync, defaultVerifyOpts, _verify, verifyAsync, hashes, randomSecretKey, keygenAsync, W, scalarBits, pwindows, pwindowSize, precompute, Gpows, ctneg, wNAF, SIGNED_TOKEN_SUITE, BASE58_ALPHABET, NODE_TAG_V2, LEAF_TAG_V2, SKILL_SIGNATURE_SUITE, EXECUTION_RECEIPT_SUITE, TOOL_INVOCATION_RECEIPT_SUITE, COMPUTER_SESSION_RECEIPT_SUITE, DELEGATION_TOKEN_SUITE, ADJUDICATOR_VOTE_SUITE, DISPUTE_RESOLUTION_SUITE, DISPUTE_REQUEST_SUITE, DISPUTE_EVIDENCE_SUITE, DISPUTE_APPEAL_SUITE, CONSOLIDATION_RECEIPT_SUITE, BALANCE_WAIVER_SUITE, SETTLEMENT_RECORD_SUITE, FEDERATION_SETTLEMENT_RECORD_SUITE, KEY_SUCCESSION_SUITE, GUARDIAN_REVOCATION_SUITE, COLLABORATIVE_RECEIPT_SUITE, DEVICE_REGISTRATION_SUITE, DEVICE_REGISTRATION_MAX_AGE_MS, VC_TYPE_GRADIENT2, VC_TYPE_REPUTATION2, VC_TYPE_TRUST2, ONE_HOUR_MS, CONTENT_ARTIFACT_SUITE, CREDENTIAL_ANCHOR_SUITE, REVOCATION_ANCHOR_SUITE, AGENT_SETTLEMENT_ANCHOR_SUITE, FEDERATION_SETTLEMENT_ANCHOR_SUITE, DELETION_CERTIFICATE_SUITE, WITNESS_OMISSION_DISPUTE_WINDOW_MS, EMPTY_FEDERATION_GRAPH_ANCHOR_ROOT, REASON_TABLE, WITNESS_OMISSION_DISPUTE_SUITE, FEDERATION_HEARTBEAT_SUITE, HEARTBEAT_FRESHNESS_WINDOW_MS, BASE58_ALPHABET2, IDENTITY_FILE_SUITE, SIG_PREFIX, SIG_SUFFIX, DEFAULT_CLOCK_SKEW_SECONDS;
+var __defProp2, __getOwnPropNames2, __esm2, __export2, hasHexBuiltin, hexes, asciis, oidNist, init_utils, HashMD, SHA256_IV, SHA384_IV, SHA512_IV, init_md, U32_MASK64, _32n, shrSH, shrSL, rotrSH, rotrSL, rotrBH, rotrBL, add3L, add3H, add4L, add4H, add5L, add5H, init_u64, SHA256_K, SHA256_W, SHA2_32B, _SHA256, K512, SHA512_Kh, SHA512_Kl, SHA512_W_H, SHA512_W_L, SHA2_64B, _SHA512, _SHA384, sha256, sha512, sha384, init_sha2, abytes3, anumber2, bytesToHex3, concatBytes3, hexToBytes3, isBytes3, randomBytes3, _0n, _1n, isPosBig, bitMask, init_utils2, _0n2, _1n2, _2n, _3n, _4n, _5n, _7n, _8n, _9n, _16n, FIELD_FIELDS, FIELD_SQRT, _Field, init_modular, _0n3, _1n3, pointPrecomputes, pointWindowSizes, wNAF2, init_curve, init_fft, os2ip, _DST_scalar, init_hash_to_curve, validateSigners, validateCommitmentsNum, AggErr, init_frost, _DST_scalarBytes, init_oprf, _HMAC, hmac, init_hmac, divNearest, DERErr, DER, _0n4, _1n4, _2n2, _3n2, _4n2, init_weierstrass, nist_exports, p256_CURVE, p384_CURVE, p521_CURVE, p256_Point, p256, p256_hasher, p256_oprf, p256_FROST, p384_Point, p384, p384_hasher, p384_oprf, p521_Point, p521, p521_hasher, p521_oprf, init_nist, ed25519_CURVE, P, N, Gx, Gy, _a, _d, h, L, captureTrace, err, isBig, isStr, isBytes, abytes, u8n, u8fr, padh, bytesToHex, C, _ch, hexToBytes, cr, subtle, concatBytes, randomBytes, big, assertRange, M, P_MASK, modP, modN, invert, callHash, checkDigest, apoint, B256, Point, G, I, numTo32bLE, bytesToNumberLE, pow2, pow_2_252_3, RM1, uvRatio, modL_LE, sha512a, hash2extK, getExtendedPublicKeyAsync, getPublicKeyAsync, hashFinishA, _sign, signAsync, defaultVerifyOpts, _verify, verifyAsync, hashes, randomSecretKey, keygenAsync, W, scalarBits, pwindows, pwindowSize, precompute, Gpows, ctneg, wNAF, SIGNED_TOKEN_SUITE, BASE58_ALPHABET, NODE_TAG_V2, LEAF_TAG_V2, EXECUTION_RECEIPT_SUITE, TOOL_INVOCATION_RECEIPT_SUITE, COMPUTER_SESSION_RECEIPT_SUITE, DELEGATION_TOKEN_SUITE, ADJUDICATOR_VOTE_SUITE, DISPUTE_RESOLUTION_SUITE, DISPUTE_REQUEST_SUITE, DISPUTE_EVIDENCE_SUITE, DISPUTE_APPEAL_SUITE, APPROVAL_DECISION_SUITE, CONSOLIDATION_RECEIPT_SUITE, BALANCE_WAIVER_SUITE, SETTLEMENT_RECORD_SUITE, FEDERATION_SETTLEMENT_RECORD_SUITE, KEY_SUCCESSION_SUITE, GUARDIAN_REVOCATION_SUITE, COLLABORATIVE_RECEIPT_SUITE, DEVICE_REGISTRATION_SUITE, DEVICE_REGISTRATION_MAX_AGE_MS, SKILL_SIGNATURE_SUITE, VC_TYPE_GRADIENT2, VC_TYPE_REPUTATION2, VC_TYPE_TRUST2, ONE_HOUR_MS, CONTENT_ARTIFACT_SUITE, CREDENTIAL_ANCHOR_SUITE, REVOCATION_ANCHOR_SUITE, AGENT_SETTLEMENT_ANCHOR_SUITE, FEDERATION_SETTLEMENT_ANCHOR_SUITE, DELETION_CERTIFICATE_SUITE, WITNESS_OMISSION_DISPUTE_WINDOW_MS, EMPTY_FEDERATION_GRAPH_ANCHOR_ROOT, REASON_TABLE, WITNESS_OMISSION_DISPUTE_SUITE, FEDERATION_HEARTBEAT_SUITE, HEARTBEAT_FRESHNESS_WINDOW_MS, BASE58_ALPHABET2, IDENTITY_FILE_SUITE, SIG_PREFIX, SIG_SUFFIX, DEFAULT_CLOCK_SKEW_SECONDS;
 var init_dist5 = __esm({
   "../../packages/crypto/dist/index.js"() {
     "use strict";
@@ -17108,7 +17189,6 @@ var init_dist5 = __esm({
     BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
     NODE_TAG_V2 = new Uint8Array([1]);
     LEAF_TAG_V2 = new Uint8Array([0]);
-    SKILL_SIGNATURE_SUITE = "motebit-jcs-ed25519-b64-v1";
     EXECUTION_RECEIPT_SUITE = "motebit-jcs-ed25519-b64-v1";
     TOOL_INVOCATION_RECEIPT_SUITE = "motebit-jcs-ed25519-b64-v1";
     COMPUTER_SESSION_RECEIPT_SUITE = "motebit-jcs-ed25519-b64-v1";
@@ -17118,6 +17198,7 @@ var init_dist5 = __esm({
     DISPUTE_REQUEST_SUITE = "motebit-jcs-ed25519-b64-v1";
     DISPUTE_EVIDENCE_SUITE = "motebit-jcs-ed25519-b64-v1";
     DISPUTE_APPEAL_SUITE = "motebit-jcs-ed25519-b64-v1";
+    APPROVAL_DECISION_SUITE = "motebit-jcs-ed25519-b64-v1";
     CONSOLIDATION_RECEIPT_SUITE = "motebit-jcs-ed25519-b64-v1";
     BALANCE_WAIVER_SUITE = "motebit-jcs-ed25519-b64-v1";
     SETTLEMENT_RECORD_SUITE = "motebit-jcs-ed25519-b64-v1";
@@ -17127,6 +17208,7 @@ var init_dist5 = __esm({
     COLLABORATIVE_RECEIPT_SUITE = "motebit-jcs-ed25519-b64-v1";
     DEVICE_REGISTRATION_SUITE = "motebit-jcs-ed25519-b64-v1";
     DEVICE_REGISTRATION_MAX_AGE_MS = 5 * 60 * 1e3;
+    SKILL_SIGNATURE_SUITE = "motebit-jcs-ed25519-b64-v1";
     VC_TYPE_GRADIENT2 = "AgentGradientCredential";
     VC_TYPE_REPUTATION2 = "AgentReputationCredential";
     VC_TYPE_TRUST2 = "AgentTrustCredential";
@@ -18641,7 +18723,7 @@ var init_config2 = __esm({
   "src/config.ts"() {
     "use strict";
     init_esm_shims();
-    VERSION = true ? "1.4.2" : "0.0.0-dev";
+    VERSION = true ? "1.4.3" : "0.0.0-dev";
     CONFIG_DIR = process.env["MOTEBIT_CONFIG_DIR"] ?? path2.join(os.homedir(), ".motebit");
     CONFIG_PATH = path2.join(CONFIG_DIR, "config.json");
     RELAY_DIR = path2.join(CONFIG_DIR, "relay");
@@ -40565,7 +40647,9 @@ var init_streaming = __esm({
               args: chunk.args,
               userMessage,
               runId,
-              quorum: chunk.quorum
+              quorum: chunk.quorum,
+              riskLevel: chunk.risk_level,
+              requestedAt: Date.now()
             };
             const approvalStore = this.deps.getApprovalStore();
             if (chunk.quorum && approvalStore) {
@@ -40617,6 +40701,7 @@ var init_streaming = __esm({
         this.deps.pushStateUpdate({ processing: 0.9, attention: 0.8 });
         this.deps.setSpeaking(true);
         try {
+          await this.signAndEmitApprovalDecision(pending, approved);
           if (approved) {
             yield { type: "tool_status", name: pending.toolName, status: "calling" };
             const toolRegistry = this.deps.getToolRegistry();
@@ -40662,6 +40747,55 @@ var init_streaming = __esm({
           this._isProcessing = false;
         }
       }
+      /**
+       * Build, sign, and emit the human-consent decision for a resolved approval.
+       * Signed by the APPROVER's device key — consent is the approver's own
+       * assertion, mirroring how the worker signs its own refusal. Commits to
+       * `args_hash` (never raw args), the gated `approval_id` (= tool_call_id), the
+       * verdict, and the requested/resolved timestamps, so a third party can verify
+       * offline that this approver consented to THIS call at THIS time.
+       *
+       * Best-effort and fail-open on the AUDIT side only: if the signing material
+       * is absent (no device key wired) or signing throws, the resume still
+       * proceeds — the decision artifact is an audit record layered on top of the
+       * already-enforced gate, not the gate itself. Mirrors `onToolInvocation`.
+       */
+      async signAndEmitApprovalDecision(pending, approved) {
+        const sink = this.deps.onApprovalDecision;
+        if (!sink)
+          return;
+        const deviceId = this.deps.getDeviceId?.() ?? null;
+        const privateKey = this.deps.getSigningPrivateKey?.() ?? null;
+        const publicKey = this.deps.getSigningPublicKey?.() ?? null;
+        if (!deviceId || !privateKey || !this.deps.motebitId)
+          return;
+        try {
+          const argsHash = await hashToolPayload(pending.args);
+          const unsigned = {
+            approval_id: pending.toolCallId,
+            motebit_id: this.deps.motebitId,
+            device_id: deviceId,
+            tool_name: pending.toolName,
+            args_hash: argsHash,
+            risk_level: pending.riskLevel ?? 0,
+            verdict: approved ? "approved" : "denied",
+            requested_at: pending.requestedAt,
+            resolved_at: Date.now(),
+            ...approved ? {} : { denied_reason: "User denied this tool call." },
+            ...pending.runId != null ? { run_id: pending.runId } : {}
+          };
+          const signed = await signApprovalDecision(unsigned, privateKey, publicKey ?? void 0);
+          try {
+            sink(signed);
+          } catch (err2) {
+            const msg = err2 instanceof Error ? err2.message : String(err2);
+            console.warn(`[streaming] onApprovalDecision sink threw: ${msg}`);
+          }
+        } catch (err2) {
+          const msg = err2 instanceof Error ? err2.message : String(err2);
+          console.warn(`[streaming] failed to sign approval decision: ${msg}`);
+        }
+      }
       /**
        * Record a single approval vote for multi-party (quorum) approval.
        * - If no quorum is configured, delegates to resumeAfterApproval (backward compat).
@@ -42105,6 +42239,8 @@ async function* handleAgentTask(deps, task, privateKey, deviceId, publicKey, opt
   const toolsUsed = [];
   let memoriesFormed = 0;
   let status = "completed";
+  let toolCallsSucceeded = 0;
+  let toolCallsDenied = 0;
   try {
     const stream = deps.sendMessageStreaming(task.prompt, void 0, {
       delegationScope: options?.delegatedScope
@@ -42124,6 +42260,8 @@ async function* handleAgentTask(deps, task, privateKey, deviceId, publicKey, opt
       } else if (chunk.type === "result") {
         responseText = chunk.result.response;
         memoriesFormed = chunk.result.memoriesFormed.length;
+        toolCallsSucceeded = chunk.result.toolCallsSucceeded;
+        toolCallsDenied = chunk.result.toolCallsDenied ?? 0;
       }
       yield chunk;
     }
@@ -42134,6 +42272,10 @@ async function* handleAgentTask(deps, task, privateKey, deviceId, publicKey, opt
     clearTimeout(timeout);
     deps.restoreConversationContext(savedCtx);
   }
+  if (status === "completed" && toolCallsSucceeded === 0 && toolCallsDenied > 0) {
+    status = "denied";
+    responseText = `Task refused by governance: ${toolCallsDenied} action(s) exceeded this motebit's policy (deny_above / denylist / delegated scope) and no permitted action completed.` + (responseText ? ` Model note: ${responseText}` : "");
+  }
   const delegationReceipts = [];
   for (const adapter of deps.getMcpAdapters()) {
     if (adapter.getAndResetDelegationReceipts) {
@@ -42612,6 +42754,8 @@ var init_motebit_runtime = __esm({
        * persist the payload beyond the call.
        */
       _onToolActivity;
+      /** Surface sink for signed human-consent decisions (the "approve" band artifact). */
+      _onApprovalDecision;
       /**
        * receipts-1 — in-memory buffer of recent signed
        * `ToolInvocationReceipt`s, capped at `RECEIPTS_BUFFER_CAP`.
@@ -42635,6 +42779,8 @@ var init_motebit_runtime = __esm({
        */
       _recentReceipts = [];
       static RECEIPTS_BUFFER_CAP = 50;
+      /** In-session buffer of signed human-consent decisions (newest last), same cap + contract as `_recentReceipts`. */
+      _recentApprovalDecisions = [];
       constructor(config, adapters) {
         assertSpeciesIntegrity();
         this.motebitId = config.motebitId;
@@ -42656,6 +42802,7 @@ var init_motebit_runtime = __esm({
           }
         };
         this._onToolActivity = config.onToolActivity ?? null;
+        this._onApprovalDecision = config.onApprovalDecision ?? null;
         this.compactionThreshold = config.compactionThreshold ?? 1e3;
         this.mcpConfigs = config.mcpServers ?? [];
         this.taskRouter = config.taskRouter ? new TaskRouter(config.taskRouter) : null;
@@ -42957,10 +43104,36 @@ var init_motebit_runtime = __esm({
           getSigningPrivateKey: () => this._signingKeys?.privateKey ?? null,
           getSigningPublicKey: () => this._signingKeys?.publicKey ?? null,
           onToolInvocation: this._onToolInvocation ? (receipt) => this._onToolInvocation?.(receipt) : void 0,
-          onToolActivity: this._onToolActivity ? (event) => this._onToolActivity?.(event) : void 0
+          onToolActivity: this._onToolActivity ? (event) => this._onToolActivity?.(event) : void 0,
+          onApprovalDecision: (decision) => this.recordApprovalDecision(decision)
         });
         this.wireLoopDeps();
       }
+      /**
+       * Buffer a signed human-consent decision and forward it to the surface sink —
+       * the exact shape as `_onToolInvocation`: push to the in-session buffer FIRST
+       * (so `getRecentApprovalDecisions()` is correct regardless of whether a
+       * surface listener throws), then fan out. Deliberately does NOT append an
+       * event-log entry: the daemon/goal path already records its own
+       * `ApprovalApproved`/`ApprovalDenied` goal-audit event (`apps/cli` scheduler),
+       * so a runtime append would double-emit; and durable cross-restart archival of
+       * the signed artifact is a separate, consumer-shaped concern (a dedicated
+       * retrieval surface), deferred until a consumer forces its shape — the same
+       * sequencing the delegation refusal path used for receipt retrieval.
+       */
+      recordApprovalDecision(decision) {
+        this._recentApprovalDecisions.push(decision);
+        if (this._recentApprovalDecisions.length > _MotebitRuntime.RECEIPTS_BUFFER_CAP) {
+          this._recentApprovalDecisions.shift();
+        }
+        if (this._onApprovalDecision) {
+          try {
+            this._onApprovalDecision(decision);
+          } catch (err2) {
+            this._logger.warn(`[runtime] surface onApprovalDecision threw: ${err2 instanceof Error ? err2.message : String(err2)}`);
+          }
+        }
+      }
       // === Lifecycle ===
       async init(target) {
         this._sessionStartedAt = this._clock?.() ?? Date.now();
@@ -44854,6 +45027,18 @@ var init_motebit_runtime = __esm({
       getRecentReceipts() {
         return this._recentReceipts;
       }
+      /**
+       * Recent signed human-consent decisions (`ApprovalDecision`), newest last,
+       * capped at `RECEIPTS_BUFFER_CAP`. The "approve" governance band's
+       * counterpart to `getRecentReceipts()`: each entry is the approver's signed,
+       * offline-verifiable verdict over a gated tool call. Empty when no decisions
+       * were rendered this session, or when no signing key was wired (fail-closed —
+       * the runtime emits nothing rather than an unsigned decision). Durable
+       * cross-restart archival is a deferred, consumer-shaped concern.
+       */
+      getRecentApprovalDecisions() {
+        return this._recentApprovalDecisions;
+      }
       /**
        * Per-session pixel-passthrough consent. Composed into the loop's
        * `projectForAi` pixel gate alongside provider mode and effective
@@ -74223,6 +74408,59 @@ var init_accounts = __esm({
   }
 });
 
+// ../../services/relay/dist/receipts-store.js
+function receiptTaskId(r2) {
+  return r2.relay_task_id != null && r2.relay_task_id.length > 0 ? r2.relay_task_id : r2.task_id;
+}
+function persistReceiptChain(db, receipt, parentTaskId = null, depth = 0, receivedAt = Date.now()) {
+  if (depth > MAX_RECEIPT_DEPTH) {
+    logger13.warn("receipt.persist.depth_limit_exceeded", {
+      motebitId: receipt.motebit_id,
+      taskId: receiptTaskId(receipt),
+      depth,
+      maxDepth: MAX_RECEIPT_DEPTH
+    });
+    return;
+  }
+  const taskId = receiptTaskId(receipt);
+  const receiptJson = canonicalJson(receipt);
+  db.prepare(INSERT_SQL).run(receipt.motebit_id, taskId, parentTaskId, depth, receipt.status, receipt.suite, receipt.public_key ?? "", receipt.signature, receipt.invocation_origin ?? null, receiptJson, receivedAt);
+  const children = receipt.delegation_receipts ?? [];
+  for (const child of children) {
+    persistReceiptChain(db, child, taskId, depth + 1, receivedAt);
+  }
+}
+function getStoredReceiptJson(db, motebitId, taskId) {
+  const row = db.prepare("SELECT receipt_json FROM relay_receipts WHERE motebit_id = ? AND task_id = ?").get(motebitId, taskId);
+  return row?.receipt_json ?? null;
+}
+function listStoredReceipts(db, motebitId, limit = 50) {
+  const capped = Math.max(1, Math.min(limit, 200));
+  return db.prepare(`SELECT task_id, status, invocation_origin, received_at, receipt_json
+         FROM relay_receipts
+        WHERE motebit_id = ? AND depth = 0
+        ORDER BY received_at DESC
+        LIMIT ?`).all(motebitId, capped);
+}
+var logger13, MAX_RECEIPT_DEPTH, INSERT_SQL;
+var init_receipts_store = __esm({
+  "../../services/relay/dist/receipts-store.js"() {
+    "use strict";
+    init_esm_shims();
+    init_dist6();
+    init_logger();
+    logger13 = createLogger({ service: "receipts-store" });
+    MAX_RECEIPT_DEPTH = 10;
+    INSERT_SQL = `
+  INSERT OR IGNORE INTO relay_receipts (
+    motebit_id, task_id, parent_task_id, depth, status,
+    suite, public_key, signature, invocation_origin,
+    receipt_json, received_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+`;
+  }
+});
+
 // ../../services/relay/dist/agent-revocation.js
 async function buildSignedRevocationRecord(relayIdentity, input, now = Date.now()) {
   const payload = {
@@ -74603,6 +74841,8 @@ function registerAgentRoutes(deps) {
       agentAudience = "credentials";
     } else if (path19.includes("/presentation")) {
       agentAudience = "credentials:present";
+    } else if (path19.includes("/receipts")) {
+      agentAudience = "receipts:read";
     } else {
       agentAudience = "admin:query";
     }
@@ -74613,6 +74853,27 @@ function registerAgentRoutes(deps) {
     c3.set("callerMotebitId", claims.mid);
     await next();
   });
+  app.get("/api/v1/agents/:motebitId/receipts", (c3) => {
+    const motebitId = c3.req.param("motebitId");
+    const caller = c3.get("callerMotebitId");
+    if (caller !== void 0 && caller !== motebitId) {
+      throw new HTTPException4(403, { message: "Cannot read another motebit's receipts" });
+    }
+    const limit = parseInt(c3.req.query("limit") ?? "50", 10) || 50;
+    return c3.json({ receipts: listStoredReceipts(moteDb.db, motebitId, limit) });
+  });
+  app.get("/api/v1/agents/:motebitId/receipts/:taskId", (c3) => {
+    const motebitId = c3.req.param("motebitId");
+    const caller = c3.get("callerMotebitId");
+    if (caller !== void 0 && caller !== motebitId) {
+      throw new HTTPException4(403, { message: "Cannot read another motebit's receipts" });
+    }
+    const json = getStoredReceiptJson(moteDb.db, motebitId, c3.req.param("taskId"));
+    if (json === null) {
+      throw new HTTPException4(404, { message: "No such receipt" });
+    }
+    return c3.body(json, 200, { "content-type": "application/json" });
+  });
   app.post("/api/v1/agents/bootstrap", async (c3) => {
     const body = await c3.req.json();
     if (!body.motebit_id || typeof body.motebit_id !== "string" || body.motebit_id.trim() === "") {
@@ -74757,7 +75018,7 @@ function registerAgentRoutes(deps) {
       }
       moteDb.db.prepare(`INSERT INTO relay_key_successions (motebit_id, old_public_key, new_public_key, timestamp, reason, old_key_signature, new_key_signature, recovery, guardian_signature)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(motebitId, succession.old_public_key, succession.new_public_key, succession.timestamp, succession.reason ?? null, succession.old_key_signature ?? null, succession.new_key_signature, succession.recovery ? 1 : 0, succession.guardian_signature ?? null);
-      logger13.info("agent.key.succession_on_register", {
+      logger14.info("agent.key.succession_on_register", {
         motebitId,
         oldKey: existingAgent.public_key.slice(0, 16) + "...",
         newKey: publicKey.slice(0, 16) + "..."
@@ -75050,7 +75311,7 @@ function registerAgentRoutes(deps) {
       note
     });
     insertRevocationRecord(moteDb.db, record);
-    logger13.info(revoked ? "agent.revoked" : "agent.reinstated", {
+    logger14.info(revoked ? "agent.revoked" : "agent.reinstated", {
       motebit_id: motebitId,
       reason
     });
@@ -75122,7 +75383,7 @@ function registerAgentRoutes(deps) {
     return c3.json({ ok: true });
   });
 }
-var logger13, SOLVENCY_TTL_MS;
+var logger14, SOLVENCY_TTL_MS;
 var init_agents = __esm({
   "../../services/relay/dist/agents.js"() {
     "use strict";
@@ -75135,10 +75396,11 @@ var init_agents = __esm({
     init_dist30();
     init_idempotency();
     init_accounts();
+    init_receipts_store();
     init_dist();
     init_agent_revocation3();
     init_logger();
-    logger13 = createLogger({ service: "agents" });
+    logger14 = createLogger({ service: "agents" });
     SOLVENCY_TTL_MS = 5 * 60 * 1e3;
   }
 });
@@ -75296,7 +75558,7 @@ async function insertRevocationEvent(db, relayIdentity, type, motebitId, opts) {
   db.prepare("INSERT INTO relay_revocation_events (event_id, type, motebit_id, credential_id, new_public_key, timestamp, signature) VALUES (?, ?, ?, ?, ?, ?, ?)").run(eventId, type, motebitId, opts?.credentialId ?? null, opts?.newPublicKey ?? null, recordedAt, signatureHex);
   if (revocationAnchorSubmitter && opts?.revokedPublicKey) {
     anchorRevocationOnChain(opts.revokedPublicKey, effectiveAt).catch((err2) => {
-      logger14.error("revocation.anchor_failed", {
+      logger15.error("revocation.anchor_failed", {
         motebitId,
         type,
         error: err2 instanceof Error ? err2.message : String(err2)
@@ -75317,13 +75579,13 @@ async function anchorRevocationOnChain(revokedPublicKeyHex, timestamp) {
     return;
   const available = await revocationAnchorSubmitter.isAvailable();
   if (!available) {
-    logger14.warn("revocation.anchor_submitter_unavailable", {
+    logger15.warn("revocation.anchor_submitter_unavailable", {
       publicKey: revokedPublicKeyHex.slice(0, 16) + "..."
     });
     return;
   }
   const { txHash } = await revocationAnchorSubmitter.submitRevocation(revokedPublicKeyHex, timestamp);
-  logger14.info("revocation.anchored_onchain", {
+  logger15.info("revocation.anchored_onchain", {
     publicKey: revokedPublicKeyHex.slice(0, 16) + "...",
     txHash,
     timestamp
@@ -75341,7 +75603,7 @@ async function processIncomingRevocations(db, events, peerPublicKey) {
     const valid = await ed25519Verify(hexToBytes5(event.signature), encoder2.encode(payload), peerPublicKey);
     if (!valid) {
       rejected++;
-      logger14.warn("federation.revocation.invalid_signature", {
+      logger15.warn("federation.revocation.invalid_signature", {
         type: event.type,
         motebitId: event.motebit_id
       });
@@ -75519,13 +75781,13 @@ async function sendHeartbeats(db, relayIdentity) {
       const newMissed = peer.missed_heartbeats + 1;
       if (newMissed >= HEARTBEAT_REMOVE_THRESHOLD) {
         db.prepare("UPDATE relay_peers SET missed_heartbeats = ?, state = 'removed' WHERE peer_relay_id = ?").run(newMissed, peer.peer_relay_id);
-        logger14.warn("federation.peer.suspended", { peerId: peer.peer_relay_id });
+        logger15.warn("federation.peer.suspended", { peerId: peer.peer_relay_id });
       } else if (newMissed >= HEARTBEAT_SUSPEND_THRESHOLD) {
         db.prepare("UPDATE relay_peers SET missed_heartbeats = ?, state = 'suspended' WHERE peer_relay_id = ?").run(newMissed, peer.peer_relay_id);
-        logger14.warn("federation.peer.suspended", { peerId: peer.peer_relay_id });
+        logger15.warn("federation.peer.suspended", { peerId: peer.peer_relay_id });
       } else {
         db.prepare("UPDATE relay_peers SET missed_heartbeats = ? WHERE peer_relay_id = ?").run(newMissed, peer.peer_relay_id);
-        logger14.warn("federation.heartbeat.missed", {
+        logger15.warn("federation.heartbeat.missed", {
           peerId: peer.peer_relay_id,
           missed: newMissed
         });
@@ -75569,7 +75831,7 @@ async function processSettlementRetries(db, relayIdentity, onRetryExhausted, ret
           try {
             onRetryExhausted(retry);
           } catch (refundErr) {
-            logger14.warn("settlement.retry.refund_failed", {
+            logger15.warn("settlement.retry.refund_failed", {
               retryId: retry.retry_id,
               taskId: retry.task_id,
               error: refundErr instanceof Error ? refundErr.message : String(refundErr)
@@ -75579,7 +75841,7 @@ async function processSettlementRetries(db, relayIdentity, onRetryExhausted, ret
       } else {
         const backoffMs = nextRetryDelay(newAttempts - 1, retryPolicy);
         const nextRetry = Date.now() + backoffMs;
-        logger14.info("settlement.retry.scheduled", {
+        logger15.info("settlement.retry.scheduled", {
           retryId: retry.retry_id,
           taskId: retry.task_id,
           attempt: newAttempts,
@@ -75778,7 +76040,7 @@ function registerFederationRoutes(deps) {
     }
     const now = Date.now();
     db.prepare(`UPDATE relay_peers SET state = 'active', peered_at = ?, last_heartbeat_at = ?, nonce = NULL WHERE peer_relay_id = ?`).run(now, now, relay_id);
-    logger14.info("federation.peer.active", { peerId: relay_id });
+    logger15.info("federation.peer.active", { peerId: relay_id });
     return c3.json({ status: "active", peered_at: now });
   });
   app.post("/federation/v1/peer/heartbeat", async (c3) => {
@@ -75812,19 +76074,19 @@ function registerFederationRoutes(deps) {
         const peerPubKey = hexToBytes5(peer.public_key);
         const result = await processIncomingRevocations(db, revocations, peerPubKey);
         if (result.rejected > 0) {
-          logger14.warn("federation.revocation.rejected", {
+          logger15.warn("federation.revocation.rejected", {
             peerId: relay_id,
             rejected: result.rejected
           });
         }
         if (result.processed > 0) {
-          logger14.info("federation.revocation.processed", {
+          logger15.info("federation.revocation.processed", {
             peerId: relay_id,
             processed: result.processed
           });
         }
       } catch (err2) {
-        logger14.warn("federation.revocation.error", {
+        logger15.warn("federation.revocation.error", {
           peerId: relay_id,
           error: err2 instanceof Error ? err2.message : String(err2)
         });
@@ -75871,7 +76133,7 @@ function registerFederationRoutes(deps) {
       });
     }
     const witnessSignature = await signHorizonWitnessRequestBody(request.cert_body, relayIdentity.privateKey);
-    logger14.info("federation.horizon.witness.signed", {
+    logger15.info("federation.horizon.witness.signed", {
       issuerId: request.issuer_id,
       storeId: request.cert_body.store_id,
       horizonTs: request.cert_body.horizon_ts
@@ -75925,7 +76187,7 @@ function registerFederationRoutes(deps) {
       });
     }
     persistWitnessOmissionDispute(db, dispute, disputeJson, "verified");
-    logger14.info("federation.horizon.dispute.verified", {
+    logger15.info("federation.horizon.dispute.verified", {
       disputeId: dispute.dispute_id,
       certIssuer: dispute.cert_issuer,
       certSignature: dispute.cert_signature.slice(0, 16),
@@ -75968,7 +76230,7 @@ function registerFederationRoutes(deps) {
     const canonical = canonicalJson(bodyForVerify);
     const valid = await ed25519Verify(fromBase64Url(signature), new TextEncoder().encode(canonical), hexToBytes5(peer.public_key));
     if (!valid) {
-      logger14.warn("federation.vote_request.signature_invalid", {
+      logger15.warn("federation.vote_request.signature_invalid", {
         kind: "signature_invalid",
         peerId: request.requester_id,
         disputeId: request.dispute_id
@@ -76002,7 +76264,7 @@ function registerFederationRoutes(deps) {
       vote: voteOutcome,
       rationale: voteRationale
     }, relayIdentity.privateKey);
-    logger14.info("federation.vote_request.signed", {
+    logger15.info("federation.vote_request.signed", {
       disputeId: request.dispute_id,
       round: request.round,
       requesterId: request.requester_id,
@@ -76208,7 +76470,7 @@ function registerFederationRoutes(deps) {
     return c3.json(result);
   });
 }
-var FEDERATION_SUITE, RELAY_SPEC_VERSION, logger14, REVOCATION_TTL_MS, revocationAnchorSubmitter, PBKDF2_ITERATIONS, AUTH_TAG_BYTES, FEDERATION_QUERY_TTL_MS, HEARTBEAT_SUSPEND_THRESHOLD, HEARTBEAT_REMOVE_THRESHOLD, FEDERATION_TIMESTAMP_DRIFT_MS;
+var FEDERATION_SUITE, RELAY_SPEC_VERSION, logger15, REVOCATION_TTL_MS, revocationAnchorSubmitter, PBKDF2_ITERATIONS, AUTH_TAG_BYTES, FEDERATION_QUERY_TTL_MS, HEARTBEAT_SUSPEND_THRESHOLD, HEARTBEAT_REMOVE_THRESHOLD, FEDERATION_TIMESTAMP_DRIFT_MS;
 var init_federation = __esm({
   "../../services/relay/dist/federation.js"() {
     "use strict";
@@ -76227,7 +76489,7 @@ var init_federation = __esm({
     init_dist30();
     FEDERATION_SUITE = "motebit-concat-ed25519-hex-v1";
     RELAY_SPEC_VERSION = "motebit/relay-federation@1.2";
-    logger14 = createLogger({ service: "relay", module: "federation" });
+    logger15 = createLogger({ service: "relay", module: "federation" });
     REVOCATION_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
     PBKDF2_ITERATIONS = 6e5;
     AUTH_TAG_BYTES = 16;
@@ -76510,7 +76772,7 @@ function buildCreditOnDepositCallback(db) {
       accountStore.credit(deposit.motebitId, microAmount, "deposit", `onchain-${deposit.txHash}-${deposit.logIndex}`, `USDC deposit from ${deposit.fromAddress} on ${deposit.chain} (block ${deposit.blockNumber})`);
       db.prepare("INSERT INTO relay_deposit_log (tx_hash, log_index, agent_id, from_address, amount, chain, block_number, credited_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)").run(deposit.txHash, deposit.logIndex, deposit.motebitId, deposit.fromAddress, deposit.amountOnchain.toString(), deposit.chain, deposit.blockNumber.toString(), Date.now());
     });
-    logger15.info("deposit.detected", {
+    logger16.info("deposit.detected", {
       agentId: deposit.motebitId,
       chain: deposit.chain,
       amount: microAmount,
@@ -76534,7 +76796,7 @@ async function detectDeposits2(config) {
     maxBlocksPerCycle: config.maxBlocksPerCycle,
     confirmations,
     onDeposit: buildCreditOnDepositCallback(config.db),
-    logger: logger15
+    logger: logger16
   });
 }
 function startDepositDetector(config) {
@@ -76545,7 +76807,7 @@ function startDepositDetector(config) {
   const intervalMs = config.intervalMs ?? 15e3;
   const maxBlocksPerCycle = config.maxBlocksPerCycle ?? 1e3;
   if (!contractAddress || !config.rpc && !rpcUrl || confirmations === void 0) {
-    logger15.warn("deposit-detector.disabled", {
+    logger16.warn("deposit-detector.disabled", {
       chain: config.chain,
       reason: !contractAddress ? "no USDC contract" : !rpcUrl ? "no RPC URL" : "no confirmation depth registered (add to CONFIRMATIONS_BY_CHAIN)"
     });
@@ -76556,7 +76818,7 @@ function startDepositDetector(config) {
   const rpc = config.rpc ?? new HttpJsonRpcEvmAdapter({ rpcUrl, fetch: config.fetch });
   const store = new SqliteDepositDetectorStore(config.db);
   const onDeposit = buildCreditOnDepositCallback(config.db);
-  logger15.info("deposit-detector.started", {
+  logger16.info("deposit-detector.started", {
     chain: config.chain,
     intervalMs,
     maxBlocksPerCycle,
@@ -76573,16 +76835,16 @@ function startDepositDetector(config) {
         maxBlocksPerCycle,
         confirmations,
         onDeposit,
-        logger: logger15
+        logger: logger16
       });
       if (credits > 0) {
-        logger15.info("deposit-detector.cycle", {
+        logger16.info("deposit-detector.cycle", {
           chain: config.chain,
           creditsApplied: credits
         });
       }
     } catch (err2) {
-      logger15.warn("deposit-detector.cycle_failed", {
+      logger16.warn("deposit-detector.cycle_failed", {
         chain: config.chain,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
@@ -76591,7 +76853,7 @@ function startDepositDetector(config) {
   void tick();
   return setInterval(() => void tick(), intervalMs);
 }
-var logger15, TRANSFER_TOPIC, USDC_CONTRACTS, DEFAULT_RPC_URLS, CONFIRMATIONS_BY_CHAIN, USDC_ONCHAIN_TO_MICRO, SqliteDepositDetectorStore;
+var logger16, TRANSFER_TOPIC, USDC_CONTRACTS, DEFAULT_RPC_URLS, CONFIRMATIONS_BY_CHAIN, USDC_ONCHAIN_TO_MICRO, SqliteDepositDetectorStore;
 var init_deposit_detector = __esm({
   "../../services/relay/dist/deposit-detector.js"() {
     "use strict";
@@ -76600,7 +76862,7 @@ var init_deposit_detector = __esm({
     init_dist38();
     init_account_store_sqlite();
     init_logger();
-    logger15 = createLogger({ service: "deposit-detector" });
+    logger16 = createLogger({ service: "deposit-detector" });
     TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
     USDC_CONTRACTS = {
       "eip155:1": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
@@ -77644,13 +77906,13 @@ var stripe_webhook_adapter_exports = {};
 __export(stripe_webhook_adapter_exports, {
   StripeSubscriptionEventAdapter: () => StripeSubscriptionEventAdapter
 });
-var logger18, StripeSubscriptionEventAdapter;
+var logger19, StripeSubscriptionEventAdapter;
 var init_stripe_webhook_adapter = __esm({
   "../../services/relay/dist/webhooks/stripe-webhook-adapter.js"() {
     "use strict";
     init_esm_shims();
     init_logger();
-    logger18 = createLogger({ service: "relay", module: "stripe-webhook-adapter" });
+    logger19 = createLogger({ service: "relay", module: "stripe-webhook-adapter" });
     StripeSubscriptionEventAdapter = class {
       stripe;
       webhookSecret;
@@ -77663,7 +77925,7 @@ var init_stripe_webhook_adapter = __esm({
         try {
           event = this.stripe.webhooks.constructEvent(rawBody, signature, this.webhookSecret);
         } catch (err2) {
-          logger18.warn("webhook.signature_failed", {
+          logger19.warn("webhook.signature_failed", {
             error: err2 instanceof Error ? err2.message : String(err2)
           });
           return Promise.resolve(null);
@@ -92319,7 +92581,7 @@ async function reconcileTreasury(config) {
 
 // ../../services/relay/dist/treasury-reconciliation.js
 init_logger();
-var logger16 = createLogger({ service: "treasury-reconciliation" });
+var logger17 = createLogger({ service: "treasury-reconciliation" });
 var DEFAULT_INTERVAL_MS = 15 * 6e4;
 var DEFAULT_CONFIRMATION_LAG_BUFFER_MS = 5 * 6e4;
 var SqliteTreasuryReconciliationStore = class {
@@ -92400,11 +92662,11 @@ function startTreasuryReconciliationLoop(config) {
   const generateReconciliationId = config.generateReconciliationId ?? randomUUID;
   const store = new SqliteTreasuryReconciliationStore(config.db);
   const loopLogger = {
-    info: (event, data) => logger16.info(event, data),
-    warn: (event, data) => logger16.warn(event, data),
-    error: (event, data) => logger16.error(event, data)
+    info: (event, data) => logger17.info(event, data),
+    warn: (event, data) => logger17.warn(event, data),
+    error: (event, data) => logger17.error(event, data)
   };
-  logger16.info("treasury-reconciliation.started", {
+  logger17.info("treasury-reconciliation.started", {
     chain: config.chain,
     treasuryAddress: config.treasuryAddress,
     usdcContractAddress: config.usdcContractAddress,
@@ -92427,7 +92689,7 @@ function startTreasuryReconciliationLoop(config) {
         logger: loopLogger
       });
     } catch (err2) {
-      logger16.error("treasury-reconciliation.cycle_uncaught", {
+      logger17.error("treasury-reconciliation.cycle_uncaught", {
         chain: config.chain,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
@@ -92443,7 +92705,7 @@ init_esm_shims();
 init_dist39();
 init_logger();
 import { randomUUID as randomUUID2 } from "crypto";
-var logger17 = createLogger({ service: "solana-treasury-reconciliation" });
+var logger18 = createLogger({ service: "solana-treasury-reconciliation" });
 var DEFAULT_INTERVAL_MS2 = 15 * 6e4;
 var SqliteSolanaTreasuryReconciliationStore = class {
   db;
@@ -92489,11 +92751,11 @@ function startSolanaTreasuryReconciliationLoop(config) {
   }), chain, usdcMint);
   const store = new SqliteSolanaTreasuryReconciliationStore(config.db);
   const loopLogger = {
-    info: (event, data) => logger17.info(event, data),
-    warn: (event, data) => logger17.warn(event, data),
-    error: (event, data) => logger17.error(event, data)
+    info: (event, data) => logger18.info(event, data),
+    warn: (event, data) => logger18.warn(event, data),
+    error: (event, data) => logger18.error(event, data)
   };
-  logger17.info("solana-treasury-reconciliation.started", {
+  logger18.info("solana-treasury-reconciliation.started", {
     chain,
     treasuryAddress: reconciler.treasuryAddress,
     usdcMint,
@@ -92512,7 +92774,7 @@ function startSolanaTreasuryReconciliationLoop(config) {
         logger: loopLogger
       });
     } catch (err2) {
-      logger17.error("solana-treasury-reconciliation.cycle_uncaught", {
+      logger18.error("solana-treasury-reconciliation.cycle_uncaught", {
         chain,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
@@ -92778,7 +93040,7 @@ init_dist6();
 init_logger();
 init_accounts();
 import Stripe from "stripe";
-var logger19 = createLogger({ service: "relay", module: "proxy-tokens" });
+var logger20 = createLogger({ service: "relay", module: "proxy-tokens" });
 var DEPOSIT_MODELS = [
   "claude-opus-4-6",
   "claude-sonnet-4-6",
@@ -92839,7 +93101,7 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
     const balance = account?.balance ?? 0;
     try {
       const token = await issueProxyToken(motebitId, balance, relayIdentity);
-      logger19.info("proxy-token.issued", {
+      logger20.info("proxy-token.issued", {
         motebitId,
         balance: fromMicro(balance)
       });
@@ -92851,7 +93113,7 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
         expires_at: Date.now() + PROXY_TOKEN_TTL_MS
       });
     } catch (err2) {
-      logger19.error("proxy-token.failed", {
+      logger20.error("proxy-token.failed", {
         motebitId,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
@@ -92871,13 +93133,13 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
     }
     const newBalance = debitAccount(db, motebitId, body.amount, "fee", body.reference_id, body.description ?? "Cloud AI usage");
     if (newBalance === null) {
-      logger19.warn("proxy-debit.insufficient", {
+      logger20.warn("proxy-debit.insufficient", {
         motebitId,
         amount: body.amount
       });
       return c3.json({ success: false, balance: 0 });
     }
-    logger19.info("proxy-debit.success", {
+    logger20.info("proxy-debit.success", {
       motebitId,
       amount: body.amount,
       balanceAfter: newBalance
@@ -92916,7 +93178,7 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
             creditAccount(db, motebitId, toMicro(MONTHLY_CREDIT_USD), "deposit", refId, `Motebit Cloud subscription \u2014 $${MONTHLY_CREDIT_USD} credits`);
           }
           const account = getAccountBalance(db, motebitId);
-          logger19.info("session-status.activated", { motebitId, subscriptionId });
+          logger20.info("session-status.activated", { motebitId, subscriptionId });
           return c3.json({
             status: "complete",
             motebit_id: motebitId,
@@ -92929,7 +93191,7 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
         return c3.json({ status: "expired" });
       return c3.json({ status: "open" });
     } catch (err2) {
-      logger19.error("session-status.failed", {
+      logger20.error("session-status.failed", {
         sessionId,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
@@ -92943,7 +93205,7 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
     }
     const priceId = process.env.STRIPE_CLOUD_PRICE_ID;
     if (!priceId) {
-      logger19.error("checkout.missing_price_id", {});
+      logger20.error("checkout.missing_price_id", {});
       return c3.json({ error: "subscription checkout not configured" }, 500);
     }
     const existing = db.prepare("SELECT status FROM relay_subscriptions WHERE motebit_id = ? AND status = 'active'").get(body.motebit_id);
@@ -92968,13 +93230,13 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
         success_url: body.return_url ?? `${c3.req.url.split("/api")[0]}/?checkout_session_id={CHECKOUT_SESSION_ID}`,
         cancel_url: body.return_url ?? `${c3.req.url.split("/api")[0]}/`
       });
-      logger19.info("subscription.checkout.created", {
+      logger20.info("subscription.checkout.created", {
         motebitId: body.motebit_id,
         sessionId: session.id
       });
       return c3.json({ checkout_url: session.url, session_id: session.id });
     } catch (err2) {
-      logger19.error("subscription.checkout.failed", {
+      logger20.error("subscription.checkout.failed", {
         motebitId: body.motebit_id,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
@@ -93028,7 +93290,7 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
             getOrCreateAccount(db, event.motebit_id);
             creditAccount(db, event.motebit_id, toMicro(MONTHLY_CREDIT_USD), "deposit", refId, `Motebit Cloud subscription \u2014 $${MONTHLY_CREDIT_USD} credits`);
           }
-          logger19.info("subscription.activated", {
+          logger20.info("subscription.activated", {
             motebitId: event.motebit_id,
             subscriptionId: event.subscription_id,
             creditUsd: MONTHLY_CREDIT_USD
@@ -93044,7 +93306,7 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
           if (existingTxn != null)
             break;
           creditAccount(db, row.motebit_id, toMicro(MONTHLY_CREDIT_USD), "deposit", refId, `Motebit Cloud renewal \u2014 $${MONTHLY_CREDIT_USD} credits`);
-          logger19.info("subscription.renewed", {
+          logger20.info("subscription.renewed", {
             motebitId: row.motebit_id,
             subscriptionId: event.subscription_id,
             invoiceId: event.invoice_id,
@@ -93057,19 +93319,19 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
           if (!row)
             break;
           db.prepare("UPDATE relay_subscriptions SET status = 'cancelled', updated_at = ? WHERE stripe_subscription_id = ?").run(Date.now(), event.subscription_id);
-          logger19.info("subscription.cancelled", {
+          logger20.info("subscription.cancelled", {
             motebitId: row.motebit_id,
             subscriptionId: event.subscription_id
           });
           break;
         }
         case "ignored": {
-          logger19.debug("webhook.unhandled", { type: event.type });
+          logger20.debug("webhook.unhandled", { type: event.type });
           break;
         }
       }
     } catch (err2) {
-      logger19.error("webhook.processing_failed", {
+      logger20.error("webhook.processing_failed", {
         kind: event.kind,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
@@ -93090,10 +93352,10 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
       const periodEndSec = updated.current_period_end;
       const periodEnd = typeof periodEndSec === "number" ? periodEndSec * 1e3 : null;
       db.prepare("UPDATE relay_subscriptions SET status = 'cancelling', current_period_end = ?, updated_at = ? WHERE motebit_id = ?").run(periodEnd, Date.now(), motebitId);
-      logger19.info("subscription.cancel_scheduled", { motebitId, activeUntil: periodEnd });
+      logger20.info("subscription.cancel_scheduled", { motebitId, activeUntil: periodEnd });
       return c3.json({ status: "cancelling", active_until: periodEnd });
     } catch (err2) {
-      logger19.error("subscription.cancel_failed", {
+      logger20.error("subscription.cancel_failed", {
         motebitId,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
@@ -93112,10 +93374,10 @@ function registerProxyTokenRoutes(app, db, relayIdentity, subscriptionEventAdapt
         cancel_at_period_end: false
       });
       db.prepare("UPDATE relay_subscriptions SET status = 'active', updated_at = ? WHERE motebit_id = ?").run(Date.now(), motebitId);
-      logger19.info("subscription.resubscribed", { motebitId });
+      logger20.info("subscription.resubscribed", { motebitId });
       return c3.json({ status: "active" });
     } catch (err2) {
-      logger19.error("subscription.resubscribe_failed", {
+      logger20.error("subscription.resubscribe_failed", {
         motebitId,
         error: err2 instanceof Error ? err2.message : String(err2)
       });
@@ -93558,44 +93820,8 @@ function registerReceiptExchangeRoutes(app, config = {}) {
   };
 }
 
-// ../../services/relay/dist/receipts-store.js
-init_esm_shims();
-init_dist6();
-init_logger();
-var logger20 = createLogger({ service: "receipts-store" });
-var MAX_RECEIPT_DEPTH = 10;
-var INSERT_SQL = `
-  INSERT OR IGNORE INTO relay_receipts (
-    motebit_id, task_id, parent_task_id, depth, status,
-    suite, public_key, signature, invocation_origin,
-    receipt_json, received_at
-  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-`;
-function receiptTaskId(r2) {
-  return r2.relay_task_id != null && r2.relay_task_id.length > 0 ? r2.relay_task_id : r2.task_id;
-}
-function persistReceiptChain(db, receipt, parentTaskId = null, depth = 0, receivedAt = Date.now()) {
-  if (depth > MAX_RECEIPT_DEPTH) {
-    logger20.warn("receipt.persist.depth_limit_exceeded", {
-      motebitId: receipt.motebit_id,
-      taskId: receiptTaskId(receipt),
-      depth,
-      maxDepth: MAX_RECEIPT_DEPTH
-    });
-    return;
-  }
-  const taskId = receiptTaskId(receipt);
-  const receiptJson = canonicalJson(receipt);
-  db.prepare(INSERT_SQL).run(receipt.motebit_id, taskId, parentTaskId, depth, receipt.status, receipt.suite, receipt.public_key ?? "", receipt.signature, receipt.invocation_origin ?? null, receiptJson, receivedAt);
-  const children = receipt.delegation_receipts ?? [];
-  for (const child of children) {
-    persistReceiptChain(db, child, taskId, depth + 1, receivedAt);
-  }
-}
-function getStoredReceiptJson(db, motebitId, taskId) {
-  const row = db.prepare("SELECT receipt_json FROM relay_receipts WHERE motebit_id = ? AND task_id = ?").get(motebitId, taskId);
-  return row?.receipt_json ?? null;
-}
+// ../../services/relay/dist/index.js
+init_receipts_store();
 
 // ../../services/relay/dist/onramp.js
 init_esm_shims();
@@ -94121,6 +94347,7 @@ init_esm_shims();
 init_dist2();
 init_dist6();
 init_dist5();
+init_receipts_store();
 import { HTTPException as HTTPException10 } from "hono/http-exception";
 var MOTEBIT_RELAY_CLAIM_GENERATOR = "motebit-relay/0.5.2";
 function registerStateExportRoutes(deps) {
@@ -96508,6 +96735,68 @@ import { HTTPException as HTTPException18 } from "hono/http-exception";
 init_esm_shims();
 init_logger();
 var logger27 = createLogger({ service: "push-adapter" });
+var EXPO_PUSH_URL = "https://exp.host/--/api/v2/push/send";
+var ExpoPushAdapter = class {
+  accessToken;
+  _fetch;
+  constructor(config) {
+    this.accessToken = config?.accessToken;
+    this._fetch = config?.fetch ?? globalThis.fetch;
+  }
+  isAvailable() {
+    return true;
+  }
+  async send(pushToken, _platform, payload) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.accessToken) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    const body = {
+      to: pushToken,
+      data: payload,
+      priority: "high",
+      channelId: "agent-tasks",
+      _contentAvailable: true,
+      sound: null
+    };
+    try {
+      const res = await this._fetch(EXPO_PUSH_URL, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        return { delivered: false, error: `HTTP ${res.status}: ${text}` };
+      }
+      const json = await res.json();
+      if (json.data?.status === "error") {
+        const errorType = json.data.details?.error;
+        logger27.warn("push.send.error", {
+          pushToken: pushToken.slice(0, 20) + "...",
+          error: json.data.message,
+          errorType
+        });
+        return {
+          delivered: false,
+          error: `${errorType ?? "unknown"}: ${json.data.message ?? ""}`
+        };
+      }
+      logger27.info("push.send.ok", {
+        motebitId: payload.motebit_id,
+        pendingCount: payload.pending_count
+      });
+      return { delivered: true };
+    } catch (err2) {
+      const msg = err2 instanceof Error ? err2.message : String(err2);
+      logger27.warn("push.send.failed", { error: msg });
+      return { delivered: false, error: msg };
+    }
+  }
+};
 var pushRateLimit = /* @__PURE__ */ new Map();
 var PUSH_RATE_LIMIT_MS = 3e4;
 async function attemptPushWake(motebitId, deps) {
@@ -96542,6 +96831,7 @@ async function attemptPushWake(motebitId, deps) {
 
 // ../../services/relay/dist/tasks.js
 init_task_routing();
+init_receipts_store();
 
 // ../../services/relay/dist/multihop-depth.js
 init_esm_shims();
@@ -99516,6 +99806,8 @@ async function createSyncRelay(config) {
   const sweepInterval = startSweepLoop(moteDb.db, {}, () => getEmergencyFreeze());
   logger36.info("sweep.started", { intervalMs: 3e5 });
   const batchWithdrawalInterval = startBatchWithdrawalLoop(moteDb.db, railRegistry.list(), {}, () => getEmergencyFreeze());
+  const pushAdapter = process.env.EXPO_ACCESS_TOKEN ? new ExpoPushAdapter({ accessToken: process.env.EXPO_ACCESS_TOKEN }) : void 0;
+  logger36.info("relay.push_wake", { enabled: pushAdapter !== void 0 });
   await registerTaskRoutes({
     app,
     moteDb,
@@ -99535,7 +99827,8 @@ async function createSyncRelay(config) {
     isTokenBlacklisted,
     isAgentRevoked,
     platformFeeRate,
-    railRegistry
+    railRegistry,
+    pushAdapter
   });
   function getConnectionCount() {
     let count2 = 0;