@devlab.group/agent-commerce 1.4.1 → 1.6.0

package/dist/cli/index.js

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
-import { ZodError, z } from 'zod';
+import { isDeepStrictEqual } from 'util';
+import { z } from 'zod';
 import { existsSync, mkdirSync, readFileSync, accessSync, constants, closeSync, openSync, chmodSync, promises } from 'fs';
 import * as path from 'path';
-import { resolve, dirname, basename as basename$1, extname, join } from 'path';
+import { dirname, resolve, basename, extname, win32, join } from 'path';
 import { stringify, parse, Document, YAMLError } from 'yaml';
 import { CommanderError, Command } from 'commander';
 import picocolors from 'picocolors';
 import { randomUUID } from 'crypto';
-import { createRequire } from 'module';
+import 'module';
 import Database from 'better-sqlite3';
-import { writeFile, stat, readFile, rename, rm } from 'fs/promises';
+import { writeFile, stat, rename, rm, open } from 'fs/promises';
 import { validate } from '@scalar/openapi-parser';
 import * as clack from '@clack/prompts';
 
@@ -32,10 +33,22 @@ var init_filename = __esm({
 });
 
 // src/core/domain/common.ts
-var PROTOCOL_NAMES;
+var PROTOCOL_NAME_KEYS, PROTOCOL_NAMES, PAYMENT_METHOD_NAME_KEYS, PAYMENT_METHOD_NAMES;
 var init_common = __esm({
   "src/core/domain/common.ts"() {
-    PROTOCOL_NAMES = ["http", "mcp", "a2a", "acp"];
+    PROTOCOL_NAME_KEYS = {
+      http: true,
+      mcp: true,
+      a2a: true,
+      acp: true
+    };
+    PROTOCOL_NAMES = Object.keys(
+      PROTOCOL_NAME_KEYS
+    );
+    PAYMENT_METHOD_NAME_KEYS = { x402: true, mpp: true };
+    PAYMENT_METHOD_NAMES = Object.keys(
+      PAYMENT_METHOD_NAME_KEYS
+    );
   }
 });
 
@@ -64,10 +77,9 @@ var init_codes = __esm({
       PAYMENT_REPLAYED: 409,
       PAYMENT_PROVIDER_UNAVAILABLE: 503,
       PAYMENT_SETTLEMENT_FAILED: 502,
-      // 403, not 402: the buyer's money is not the problem. A 402 tells a client
-      // "pay and retry", which cannot fix a missing or rejected mandate, and a
-      // client that auto-pays on 402 would be charged for a request that was
-      // never going to be delivered.
+      // 403, not 402: a 402 tells a client to pay and retry, which cannot fix a
+      // missing or rejected mandate, and a client that auto-pays on 402 would be
+      // charged for a request that was never going to be delivered
       AUTHORIZATION_REQUIRED: 403,
       AUTHORIZATION_INVALID: 403,
       AUTHORIZATION_REPLAYED: 409,
@@ -81,17 +93,13 @@ var init_codes = __esm({
     };
     RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
       "PAYMENT_PROVIDER_UNAVAILABLE",
-      // Our verifier or our replay store was unreachable, so no verdict on the
-      // mandate was ever reached. That is an outage on our side, and the same
-      // proof will verify once it clears.
+      // The verifier or replay store was unreachable, so the mandate got no
+      // verdict. The same proof can verify once the outage clears.
       "AUTHORIZATION_PROVIDER_UNAVAILABLE",
       "BACKEND_TIMEOUT",
-      // Load shedding is transient by definition: the caller should back off and
-      // try again. Before this code existed the MCP adapter's queue-full path threw
-      // PROTOCOL_UNSUPPORTED — HTTP 501, retryable:false — so an agent framework
-      // keyed on the machine-readable flag (which exists precisely so clients need
-      // not parse prose) would read a momentary throttle as a permanent capability
-      // gap and stop calling the tool.
+      // Load shedding is transient: the caller should back off and try again.
+      // Clients act on this flag, and leaving it out would make a momentary
+      // throttle look like a permanent failure.
       "GATEWAY_BUSY"
     ]);
   }
@@ -127,7 +135,7 @@ var init_commerce_error = __esm({
         if (options.resourceId !== void 0) this.resourceId = options.resourceId;
         Error.captureStackTrace?.(this, _CommerceError);
       }
-      /** Non-secret, client-safe representation. */
+      /** Non-secret, client-safe representation. `cause` is never included */
       toInfo() {
         return {
           code: this.code,
@@ -151,11 +159,21 @@ var init_errors = __esm({
   }
 });
 
+// src/core/is-record.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var init_is_record = __esm({
+  "src/core/is-record.ts"() {
+  }
+});
+
 // src/core/domain/wire.ts
 var PAYMENT_INPUT_FIELD, AUTHORIZATION_INPUT_FIELD, RESERVED_INPUT_FIELDS;
 var init_wire = __esm({
   "src/core/domain/wire.ts"() {
     init_errors();
+    init_is_record();
     PAYMENT_INPUT_FIELD = "_payment";
     AUTHORIZATION_INPUT_FIELD = "_authorization";
     RESERVED_INPUT_FIELDS = [
@@ -257,17 +275,10 @@ var init_backend_http = __esm({
     init_resource();
     init_errors();
     init_logger();
+    init_is_record();
     PATH_PARAM_PATTERN = /\{([a-zA-Z0-9_.-]+)\}/g;
   }
 });
-
-// src/core/execution/event-bus.ts
-var init_event_bus = __esm({
-  "src/core/execution/event-bus.ts"() {
-  }
-});
-
-// src/core/execution/validation.ts
 function typeList(raw) {
   if (typeof raw === "string") return [raw];
   if (Array.isArray(raw) && raw.every((entry) => typeof entry === "string")) {
@@ -282,15 +293,17 @@ function isObjectSchemaNode(schema) {
 }
 var init_validation = __esm({
   "src/core/execution/validation.ts"() {
+    init_is_record();
   }
 });
 var init_pipeline = __esm({
   "src/core/execution/pipeline.ts"() {
     init_wire();
     init_errors();
+    init_is_record();
     init_backend_http();
     init_validation();
-    /* @__PURE__ */ new Set([...RESERVED_INPUT_FIELDS, "__proto__"]);
+    [...RESERVED_INPUT_FIELDS, "__proto__"];
   }
 });
 
@@ -301,17 +314,52 @@ var init_registry = __esm({
   }
 });
 
+// src/core/execution/store-event-sink.ts
+var init_store_event_sink = __esm({
+  "src/core/execution/store-event-sink.ts"() {
+    init_errors();
+  }
+});
+
 // src/core/execution/index.ts
 var init_execution = __esm({
   "src/core/execution/index.ts"() {
     init_backend_http();
-    init_event_bus();
     init_pipeline();
     init_registry();
+    init_store_event_sink();
     init_validation();
   }
 });
 
+// src/payments/mpp/constants.ts
+function isMppNetwork(value) {
+  return MPP_NETWORKS.includes(value);
+}
+var MPP_SPEC_COMMIT, MPP_SPEC_DRAFTS, MPP_MIN_CHALLENGE_SECRET_LENGTH, MPPX_VERSION, MPP_PROFILE, MPP_NETWORKS, MPP_DEFAULT_NETWORK;
+var init_constants2 = __esm({
+  "src/payments/mpp/constants.ts"() {
+    MPP_SPEC_COMMIT = "806fdb8b8c92cda5c84b8660558921b6bbeef7e0";
+    MPP_SPEC_DRAFTS = {
+      core: "draft-httpauth-payment-00",
+      intent: "draft-payment-intent-charge-00",
+      method: "draft-evm-charge-00"
+    };
+    MPP_MIN_CHALLENGE_SECRET_LENGTH = 32;
+    MPPX_VERSION = "0.10.1";
+    MPP_PROFILE = {
+      intent: "charge",
+      method: "evm",
+      credentialType: "authorization",
+      assetSymbol: "USDC",
+      assetDecimals: 6
+    };
+    MPP_NETWORKS = ["eip155:84532", "eip155:8453"];
+    MPP_DEFAULT_NETWORK = "eip155:84532";
+    `mpp/${MPP_SPEC_DRAFTS.core} intent=${MPP_PROFILE.intent} method=${MPP_PROFILE.method}`;
+  }
+});
+
 // src/payments/x402/networks.ts
 function findNetworkProfile(id) {
   return BY_ID.get(id);
@@ -366,13 +414,13 @@ var init_networks = __esm({
     ];
     BY_ID = new Map(PROFILES.map((profile) => [profile.id, profile]));
     SUPPORTED_NETWORK_IDS = PROFILES.map((p) => p.id);
-    LIVE_MAINNET_BANNER = "LIVE MAINNET MODE \u2014 REAL FUNDS";
+    LIVE_MAINNET_BANNER = "LIVE MAINNET MODE - REAL FUNDS";
   }
 });
 
 // src/protocols/acp/constants.ts
-var ACP_SPEC_VERSION, ACP_API_VERSION, ACP_WELL_KNOWN_PATH, ACP_CHECKOUT_OPERATIONS, ACP_OPERATION_INPUT_KEYS;
-var init_constants2 = __esm({
+var ACP_SPEC_VERSION, ACP_API_VERSION, ACP_WELL_KNOWN_PATH, ACP_CHECKOUT_OPERATIONS, ACP_OPERATION_INPUT_KEYS, ACP_OPERATION_OPTIONAL_INPUT_KEYS;
+var init_constants3 = __esm({
   "src/protocols/acp/constants.ts"() {
     ACP_SPEC_VERSION = "2026-04-17";
     ACP_API_VERSION = "2026-04-17";
@@ -391,6 +439,9 @@ var init_constants2 = __esm({
       completeCheckoutSession: ["path", "body"],
       cancelCheckoutSession: ["path"]
     };
+    ACP_OPERATION_OPTIONAL_INPUT_KEYS = {
+      cancelCheckoutSession: ["body"]
+    };
   }
 });
 
@@ -402,7 +453,7 @@ function substituteEnv(value, env, path2 = "$") {
   if (Array.isArray(value)) {
     return value.map((entry, index) => substituteEnv(entry, env, `${path2}[${index}]`));
   }
-  if (isPlainObject(value)) {
+  if (isRecord(value)) {
     const result = {};
     for (const [key, entry] of Object.entries(value)) {
       result[key] = substituteEnv(entry, env, `${path2}.${key}`);
@@ -419,16 +470,15 @@ function assertTemplateIsSupported(value, path2) {
   if (NESTED_PLACEHOLDER.test(value)) {
     throw new CommerceError(
       "CONFIG_INVALID",
-      `Configuration value at "${path2}" nests placeholders (e.g. "\${A:-\${B}}"), which is not supported \u2014 the inner one is not resolved and its closing brace ends up in the value. Use a plain default, or set the variable.`,
+      `Configuration value at "${path2}" nests placeholders (e.g. "\${A:-\${B}}"), which is not supported: the inner one is not resolved and its closing brace ends up in the value. Use a plain default, or set the variable.`,
       { details: { path: path2 } }
     );
   }
-  BRACE_TOKEN.lastIndex = 0;
   for (const [token] of value.matchAll(BRACE_TOKEN)) {
     if (SUPPORTED_TOKEN.test(token)) continue;
     throw new CommerceError(
       "CONFIG_INVALID",
-      `Configuration value at "${path2}" contains "${token}", which is not a supported placeholder. Only "\${VAR}" and "\${VAR:-default}" are recognised; shell forms such as "\${VAR-default}", "\${VAR:=default}" and "\${VAR:?message}" would load as literal text.`,
+      `Configuration value at "${path2}" contains "${token}", which is not a supported placeholder. Only "\${VAR}" and "\${VAR:-default}" are recognized; shell forms such as "\${VAR-default}", "\${VAR:=default}" and "\${VAR:?message}" would load as literal text.`,
       { details: { path: path2, token } }
     );
   }
@@ -453,13 +503,11 @@ function substituteOnce(value, env, path2) {
     }
   );
 }
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 var PLACEHOLDER_PATTERN, BRACE_TOKEN, SUPPORTED_TOKEN, NESTED_PLACEHOLDER;
 var init_env = __esm({
   "src/config/env.ts"() {
     init_core();
+    init_is_record();
     PLACEHOLDER_PATTERN = /\$\{([A-Za-z_][A-Za-z0-9_]*)(:-([^}]*))?\}/g;
     BRACE_TOKEN = /\$\{[^{}]*\}/g;
     SUPPORTED_TOKEN = /^\$\{[A-Za-z_][A-Za-z0-9_]*(:-[^}]*)?\}$/;
@@ -497,7 +545,7 @@ function isWellKnownDevAddress(address) {
 }
 function isLikelyLocalOrPrivateHost(hostname) {
   const h = hostname.toLowerCase().replace(/^\[|\]$/g, "");
-  if (h === "localhost" || h === "127.0.0.1" || h === "::1") return true;
+  if (h === "localhost" || h === "::1") return true;
   if (/^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
   if (/^10\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
   if (/^192\.168\.\d{1,3}\.\d{1,3}$/.test(h)) return true;
@@ -524,93 +572,95 @@ function invalid(message, path2) {
   return new CommerceError("CONFIG_INVALID", message, { details: { path: path2 } });
 }
 function resolveX402Deployment(input) {
-  const profile = requireNetworkProfile(input.network, "payments.x402.network");
+  const at = input.configPath ?? "payments.x402";
+  const payTo = input.payToField ?? "payTo";
+  const profile = requireNetworkProfile(input.network, `${at}.network`);
   const mode = resolveDeploymentMode(profile, input.facilitator.mode);
   if (profile.kind === "mainnet" && input.facilitator.mode === "local") {
     throw invalid(
-      `payments.x402: network "${profile.id}" (${profile.displayName}) is a mainnet and cannot be served by facilitator.mode "local". A mainnet deployment must settle through a remote facilitator.`,
-      "payments.x402.facilitator.mode"
+      `${at}: network "${profile.id}" (${profile.displayName}) is a mainnet and cannot be served by facilitator.mode "local". A mainnet deployment must settle through a remote facilitator.`,
+      `${at}.facilitator.mode`
     );
   }
   if (mode === "mainnet" && input.allowMainnet !== true) {
     throw invalid(
-      `payments.x402: network "${profile.id}" (${profile.displayName}) settles real funds. Set payments.x402.allowMainnet: true to acknowledge this explicitly \u2014 it is never the default.`,
-      "payments.x402.allowMainnet"
+      `${at}: network "${profile.id}" (${profile.displayName}) settles real funds. Set ${at}.allowMainnet: true to acknowledge this explicitly - it is never the default.`,
+      `${at}.allowMainnet`
     );
   }
   if (input.facilitator.mode === "remote") {
-    assertFacilitatorUrlIsSafe(input.facilitator.url, mode);
+    assertFacilitatorUrlIsSafe(input.facilitator.url, mode, at);
     if (mode === "mainnet" && input.facilitator.auth.type === "none" && input.allowUnauthenticatedFacilitator !== true) {
       throw invalid(
-        `payments.x402: facilitator ${describeOrigin(input.facilitator.url)} takes no credential, and this is a mainnet deployment. It will see every payment authorisation you handle, with no account, terms or support behind it. Set payments.x402.allowUnauthenticatedFacilitator: true to accept that, or configure facilitator.auth.`,
-        "payments.x402.allowUnauthenticatedFacilitator"
+        `${at}: no credential is configured for facilitator ${describeOrigin(input.facilitator.url)} on mainnet. Set ${at}.allowUnauthenticatedFacilitator: true to accept anonymous access and the facilitator's limits, or configure facilitator.auth.`,
+        `${at}.allowUnauthenticatedFacilitator`
       );
     }
     for (const [field, value] of credentialFields(input.facilitator.auth)) {
       if (value.trim() === "") {
         throw invalid(
-          `payments.x402: facilitator.auth.type is "${input.facilitator.auth.type}" but ${field} is empty. An empty credential is refused rather than sent.`,
-          `payments.x402.facilitator.auth.${field}`
+          `${at}: facilitator.auth.type is "${input.facilitator.auth.type}" but ${field} is empty. An empty credential is refused rather than sent.`,
+          `${at}.facilitator.auth.${field}`
         );
       }
     }
   }
   if (/^0x0{40}$/i.test(input.payTo)) {
     throw invalid(
-      'payments.x402: "payTo" is the zero address. Every payment settled there is destroyed.',
-      "payments.x402.payTo"
+      `${at}: "${payTo}" is the zero address. Every payment settled there is destroyed.`,
+      `${at}.${payTo}`
     );
   }
   if (mode !== "local" && isWellKnownDevAddress(input.payTo)) {
     throw invalid(
-      `payments.x402: "payTo" (${input.payTo}) is a well-known Anvil development address and this is a ${mode} deployment. Anyone can spend what settles there. Set payTo to your own merchant wallet.`,
-      "payments.x402.payTo"
+      `${at}: "${payTo}" (${input.payTo}) is a well-known Anvil development address and this is a ${mode} deployment. Anyone can spend what settles there. Set ${payTo} to your own merchant wallet.`,
+      `${at}.${payTo}`
     );
   }
   const canonical = profile.canonicalAsset;
   if (mode === "mainnet" && canonical) {
     if (!sameAddress(input.asset, canonical.address)) {
       throw invalid(
-        `payments.x402: asset ${input.asset} is not ${canonical.symbol} on ${profile.displayName} (expected ${canonical.address}). Settling a mainnet payment in an unintended token is refused.`,
-        "payments.x402.asset"
+        `${at}: asset ${input.asset} is not ${canonical.symbol} on ${profile.displayName} (expected ${canonical.address}). Settling a mainnet payment in an unintended token is refused.`,
+        `${at}.asset`
       );
     }
     if (input.assetName !== void 0 && input.assetName !== canonical.name) {
       throw invalid(
-        `payments.x402: assetName "${input.assetName}" is not the EIP-712 domain name ${canonical.symbol} reports on ${profile.displayName} (expected "${canonical.name}"). Every payment would be refused after the buyer signed.`,
-        "payments.x402.assetName"
+        `${at}: assetName "${input.assetName}" is not the EIP-712 domain name ${canonical.symbol} reports on ${profile.displayName} (expected "${canonical.name}"). Every payment would be refused after the buyer signed.`,
+        `${at}.assetName`
       );
     }
     if (input.assetVersion !== void 0 && input.assetVersion !== canonical.version) {
       throw invalid(
-        `payments.x402: assetVersion "${input.assetVersion}" is not the EIP-712 domain version ${canonical.symbol} reports on ${profile.displayName} (expected "${canonical.version}").`,
-        "payments.x402.assetVersion"
+        `${at}: assetVersion "${input.assetVersion}" is not the EIP-712 domain version ${canonical.symbol} reports on ${profile.displayName} (expected "${canonical.version}").`,
+        `${at}.assetVersion`
       );
     }
   }
   return { profile, mode };
 }
-function assertFacilitatorUrlIsSafe(url, mode) {
+function assertFacilitatorUrlIsSafe(url, mode, at) {
   let parsed;
   try {
     parsed = new URL(url);
   } catch (cause) {
-    throw new CommerceError("CONFIG_INVALID", `payments.x402: facilitator.url is not a valid URL`, {
+    throw new CommerceError("CONFIG_INVALID", `${at}: facilitator.url is not a valid URL`, {
       cause,
-      details: { path: "payments.x402.facilitator.url" }
+      details: { path: `${at}.facilitator.url` }
     });
   }
   if (parsed.protocol === "https:") return;
   if (parsed.protocol !== "http:") {
     throw invalid(
-      `payments.x402: facilitator ${describeOrigin(url)} must be reached over https (or http on a local/private host); got "${parsed.protocol}//"`,
-      "payments.x402.facilitator.url"
+      `${at}: facilitator ${describeOrigin(url)} must be reached over https (or http on a local/private host); got "${parsed.protocol}//"`,
+      `${at}.facilitator.url`
     );
   }
   if (mode !== "mainnet" && isLikelyLocalOrPrivateHost(parsed.hostname)) return;
   throw invalid(
-    `payments.x402: facilitator ${describeOrigin(url)} is reached over plain HTTP. Payment authorisations and settlement results would travel unencrypted. Use https, or point at a local/private host on a non-mainnet deployment.`,
-    "payments.x402.facilitator.url"
+    `${at}: facilitator ${describeOrigin(url)} is reached over plain HTTP. Payment authorizations and settlement results would travel unencrypted. Use https, or point at a local/private host on a non-mainnet deployment.`,
+    `${at}.facilitator.url`
   );
 }
 function describeOrigin(url) {
@@ -643,8 +693,20 @@ var init_guardrails = __esm({
     init_networks();
   }
 });
+
+// src/protocols/mcp/constants.ts
+var MCP_TOOL_NAME_CHARS, MCP_TOOL_NAME_MAX_LENGTH, MCP_TOOL_NAME_PATTERN;
+var init_constants4 = __esm({
+  "src/protocols/mcp/constants.ts"() {
+    MCP_TOOL_NAME_CHARS = "A-Za-z0-9._-";
+    MCP_TOOL_NAME_MAX_LENGTH = 128;
+    MCP_TOOL_NAME_PATTERN = new RegExp(
+      `^[${MCP_TOOL_NAME_CHARS}]{1,${MCP_TOOL_NAME_MAX_LENGTH}}$`
+    );
+  }
+});
 function parseConfig(raw, env) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+  if (!isRecord(raw)) {
     throw new CommerceError(
       "CONFIG_INVALID",
       'Configuration root must be a mapping (object) at "$"',
@@ -656,7 +718,7 @@ function parseConfig(raw, env) {
   checkVersion(raw);
   const substituted = substituteEnv(raw, env);
   const parsed = parseWithZod(RawConfigSchema, substituted);
-  return normalise(parsed);
+  return normalize(parsed);
 }
 function checkVersion(raw) {
   if (!("version" in raw)) {
@@ -664,12 +726,12 @@ function checkVersion(raw) {
       details: { path: "version" }
     });
   }
-  const rawVersion = raw["version"];
-  const version = typeof rawVersion === "string" ? Number(rawVersion) : rawVersion;
+  const version = raw["version"];
   if (version !== SUPPORTED_CONFIG_VERSION) {
+    const hint = typeof version === "string" ? ", written as a number without quotes" : "";
     throw new CommerceError(
       "CONFIG_INVALID",
-      `Unsupported config version "${String(rawVersion)}": this gateway only supports version ${SUPPORTED_CONFIG_VERSION}`,
+      `Unsupported config version "${String(version)}": this gateway only supports version ${SUPPORTED_CONFIG_VERSION}${hint}`,
       { details: { path: "version", supported: SUPPORTED_CONFIG_VERSION } }
     );
   }
@@ -740,7 +802,7 @@ function toBoolean(value, path2) {
     { details: { path: path2 } }
   );
 }
-function normalise(raw) {
+function normalize(raw) {
   const protocols = {
     http: { enabled: toBoolean(raw.protocols.http.enabled, "protocols.http.enabled") },
     mcp: {
@@ -751,16 +813,11 @@ function normalise(raw) {
       enabled: toBoolean(raw.protocols.a2a?.enabled ?? false, "protocols.a2a.enabled"),
       mountPath: raw.protocols.a2a?.mountPath ?? DEFAULT_A2A_MOUNT_PATH
     },
-    acp: normaliseAcp(raw.protocols.acp)
+    acp: normalizeAcp(raw.protocols.acp)
   };
   validateMountPaths(protocols);
   const x402Raw = raw.payments.x402;
-  const facilitator = x402Raw === void 0 ? void 0 : x402Raw.facilitator.mode === "local" ? { mode: "local", signerPrivateKey: x402Raw.facilitator.signerPrivateKey } : {
-    mode: "remote",
-    url: x402Raw.facilitator.url,
-    auth: x402Raw.facilitator.auth ?? { type: "none" }
-  };
-  const x402 = x402Raw && facilitator ? {
+  const x402 = x402Raw !== void 0 ? {
     enabled: toBoolean(x402Raw.enabled, "payments.x402.enabled"),
     network: x402Raw.network,
     rpcUrl: x402Raw.rpcUrl,
@@ -779,7 +836,7 @@ function normalise(raw) {
         min: 1
       }
     ),
-    facilitator,
+    facilitator: normalizeFacilitator(x402Raw.facilitator),
     ...x402Raw.allowMainnet !== void 0 ? { allowMainnet: toBoolean(x402Raw.allowMainnet, "payments.x402.allowMainnet") } : {},
     ...x402Raw.allowUnauthenticatedFacilitator !== void 0 ? {
       allowUnauthenticatedFacilitator: toBoolean(
@@ -802,12 +859,13 @@ function normalise(raw) {
       ...x402.allowUnauthenticatedFacilitator !== void 0 ? { allowUnauthenticatedFacilitator: x402.allowUnauthenticatedFacilitator } : {}
     });
   }
-  const ap2 = normaliseAp2(raw.authorization?.ap2);
+  const mpp = normalizeMpp(raw.payments.mpp);
+  const ap2 = normalizeAp2(raw.authorization?.ap2);
   if (ap2?.enabled) {
     validateReplayStoreIsolated(ap2.replay.path, raw.storage.receipts.path, protocols.acp);
   }
   const resources = Object.entries(raw.resources).map(
-    ([id, entry]) => normaliseResource(id, entry, protocols, x402, ap2)
+    ([id, entry]) => normalizeResource(id, entry, protocols, x402, mpp, ap2)
   );
   if (protocols.acp.enabled) validateAcpCheckoutMapping(protocols.acp, resources);
   return {
@@ -817,8 +875,7 @@ function normalise(raw) {
       name: raw.merchant.name,
       publicBaseUrl: raw.merchant.publicBaseUrl
     },
-    // min 0, not 1: port 0 is the standard "let the OS pick a free port"
-    // convention, useful for tests and ephemeral dev/demo instances.
+    // Port 0 lets the OS pick a free port, for tests and throwaway instances
     server: {
       port: toNumber(raw.server.port, "server.port", { min: 0, max: 65535 }),
       host: raw.server.host,
@@ -829,7 +886,8 @@ function normalise(raw) {
     protocols,
     resources,
     payments: {
-      ...x402 !== void 0 ? { x402 } : {}
+      ...x402 !== void 0 ? { x402 } : {},
+      ...mpp !== void 0 ? { mpp } : {}
     },
     ...ap2 !== void 0 ? { authorization: { ap2 } } : {}
   };
@@ -857,7 +915,7 @@ function validateMountPaths(protocols) {
 function ap2Invalid(path2, message, extra = {}) {
   return new CommerceError("CONFIG_INVALID", message, { details: { path: path2, ...extra } });
 }
-function normaliseAp2(raw) {
+function normalizeAp2(raw) {
   if (raw === void 0) return void 0;
   if (!toBoolean(raw.enabled, "authorization.ap2.enabled")) return { enabled: false };
   const specVersion = raw.specVersion ?? AP2_SPEC_VERSION;
@@ -877,14 +935,14 @@ function normaliseAp2(raw) {
   if (raw.replay === void 0) {
     throw ap2Invalid(
       "authorization.ap2.replay",
-      "authorization.ap2.replay is required when AP2 is enabled - it names the SQLite file recording which mandates have been spent, and without it a verified mandate could authorise a second settlement"
+      "authorization.ap2.replay is required when AP2 is enabled - it names the SQLite file recording which mandates have been spent, and without it a verified mandate could authorize a second settlement"
     );
   }
-  const mandateIssuers = normaliseIssuers(
+  const mandateIssuers = normalizeIssuers(
     raw.trust?.mandateIssuers,
     "authorization.ap2.trust.mandateIssuers"
   );
-  const checkoutIssuers = normaliseIssuers(
+  const checkoutIssuers = normalizeIssuers(
     raw.trust?.checkoutIssuers,
     "authorization.ap2.trust.checkoutIssuers"
   );
@@ -901,7 +959,7 @@ function normaliseAp2(raw) {
     replay: { path: raw.replay.path }
   };
 }
-function normaliseIssuers(raw, path2) {
+function normalizeIssuers(raw, path2) {
   if (raw === void 0 || raw.length === 0) {
     throw ap2Invalid(
       path2,
@@ -987,11 +1045,11 @@ function validateJwk(jwk, kid, path2) {
   if (jwk["kid"] !== void 0 && value("kid") !== kid) {
     fail(`declares kid "${value("kid")}", which disagrees with the configured kid "${kid}"`);
   }
-  const normalised = {};
+  const normalized = {};
   for (const member of AP2_JWK_MEMBERS) {
-    if (jwk[member] !== void 0) normalised[member] = value(member);
+    if (jwk[member] !== void 0) normalized[member] = value(member);
   }
-  return normalised;
+  return normalized;
 }
 function validateReplayStoreIsolated(replayPath, receiptsPath, acp) {
   if (replayPath === ":memory:") return;
@@ -1005,7 +1063,7 @@ function validateReplayStoreIsolated(replayPath, receiptsPath, acp) {
     );
   }
 }
-function normaliseResourceAuthorization(id, entry, pricing, ap2) {
+function normalizeResourceAuthorization(id, entry, pricing, ap2) {
   const required = entry.authorization?.required;
   if (required === void 0) return void 0;
   const path2 = `resources.${id}.authorization.required`;
@@ -1045,7 +1103,7 @@ function normaliseResourceAuthorization(id, entry, pricing, ap2) {
 function acpInvalid(path2, message, extra = {}) {
   return new CommerceError("CONFIG_INVALID", message, { details: { path: path2, ...extra } });
 }
-function normaliseAcp(raw) {
+function normalizeAcp(raw) {
   const mountPath = raw?.mountPath ?? DEFAULT_ACP_MOUNT_PATH;
   if (raw === void 0 || !toBoolean(raw.enabled, "protocols.acp.enabled")) {
     return { enabled: false, mountPath };
@@ -1075,9 +1133,8 @@ function normaliseAcp(raw) {
         { min: ACP_RETENTION_HOURS }
       )
     },
-    checkout: { operations: normaliseAcpOperations(raw.checkout) },
-    // Built key by key rather than passed through: absent metadata must stay
-    // absent from the discovery document, not appear there as `undefined`.
+    checkout: { operations: normalizeAcpOperations(raw.checkout) },
+    // Built key by key so absent metadata stays absent rather than `undefined`
     ...discovery !== void 0 ? {
       discovery: {
         ...discovery.documentationUrl !== void 0 ? { documentationUrl: discovery.documentationUrl } : {},
@@ -1088,7 +1145,7 @@ function normaliseAcp(raw) {
     } : {}
   };
 }
-function normaliseAcpOperations(checkout) {
+function normalizeAcpOperations(checkout) {
   const configured = checkout?.operations ?? {};
   for (const key of Object.keys(configured)) {
     if (!ACP_CHECKOUT_OPERATIONS.includes(key)) {
@@ -1156,13 +1213,15 @@ function validateAcpOperationInput(path2, operation, resource) {
   const schema = resource.inputSchema;
   if (schema === void 0) return;
   const keys = ACP_OPERATION_INPUT_KEYS[operation];
+  const optionalKeys = ACP_OPERATION_OPTIONAL_INPUT_KEYS[operation] ?? [];
   const properties = schema["properties"];
-  if (schema["additionalProperties"] === false && isPlainObject2(properties)) {
-    for (const key of keys) {
+  if (schema["additionalProperties"] === false && isRecord(properties)) {
+    for (const key of [...keys, ...optionalKeys]) {
       if (!Object.hasOwn(properties, key)) {
+        const when = keys.includes(key) ? "always sends" : "sends when the caller supplies it";
         throw acpInvalid(
           path2,
-          `Resource "${resource.id}" implements ACP operation "${operation}" but its input schema sets additionalProperties: false without declaring "${key}", which the adapter always sends for this operation`,
+          `Resource "${resource.id}" implements ACP operation "${operation}" but its input schema sets additionalProperties: false without declaring "${key}", which the adapter ${when} for this operation`,
           { resourceId: resource.id }
         );
       }
@@ -1174,14 +1233,81 @@ function validateAcpOperationInput(path2, operation, resource) {
       if (typeof entry === "string" && !keys.includes(entry)) {
         throw acpInvalid(
           path2,
-          `Resource "${resource.id}" implements ACP operation "${operation}" but its input schema requires "${entry}", which that operation never supplies (it sends: ${keys.join(", ")})`,
+          `Resource "${resource.id}" implements ACP operation "${operation}" but its input schema requires "${entry}", which that operation does not always supply (it always sends: ${keys.join(", ")})`,
           { resourceId: resource.id }
         );
       }
     }
   }
 }
-function normaliseResource(id, entry, protocols, x402, ap2) {
+function normalizeFacilitator(raw) {
+  return raw.mode === "local" ? { mode: "local", signerPrivateKey: raw.signerPrivateKey } : { mode: "remote", url: raw.url, auth: raw.auth ?? { type: "none" } };
+}
+function normalizeMpp(raw) {
+  if (raw === void 0) return void 0;
+  const network = raw.network ?? MPP_DEFAULT_NETWORK;
+  if (!isMppNetwork(network)) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `payments.mpp.network must be one of ${MPP_NETWORKS.join(", ")}`,
+      { details: { path: "payments.mpp.network" } }
+    );
+  }
+  const mpp = {
+    enabled: toBoolean(raw.enabled, "payments.mpp.enabled"),
+    network,
+    rpcUrl: raw.rpcUrl,
+    asset: raw.asset,
+    assetName: raw.assetName,
+    assetVersion: raw.assetVersion,
+    recipient: raw.recipient,
+    realm: raw.realm,
+    challengeSecret: raw.challengeSecret,
+    ...raw.challengeTtlSeconds !== void 0 ? {
+      challengeTtlSeconds: toNumber(
+        raw.challengeTtlSeconds,
+        "payments.mpp.challengeTtlSeconds",
+        { min: 1 }
+      )
+    } : {},
+    facilitator: normalizeFacilitator(raw.facilitator),
+    ...raw.allowMainnet !== void 0 ? { allowMainnet: toBoolean(raw.allowMainnet, "payments.mpp.allowMainnet") } : {},
+    ...raw.allowUnauthenticatedFacilitator !== void 0 ? {
+      allowUnauthenticatedFacilitator: toBoolean(
+        raw.allowUnauthenticatedFacilitator,
+        "payments.mpp.allowUnauthenticatedFacilitator"
+      )
+    } : {}
+  };
+  validateAddress("payments.mpp.recipient", mpp.recipient);
+  validateAddress("payments.mpp.asset", mpp.asset);
+  if (/[\r\n]/.test(mpp.realm)) {
+    throw new CommerceError("CONFIG_INVALID", "payments.mpp.realm must be a single line", {
+      details: { path: "payments.mpp.realm" }
+    });
+  }
+  if (mpp.challengeSecret.length < MPP_MIN_CHALLENGE_SECRET_LENGTH) {
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `payments.mpp.challengeSecret must have length at least ${MPP_MIN_CHALLENGE_SECRET_LENGTH}`,
+      { details: { path: "payments.mpp.challengeSecret" } }
+    );
+  }
+  resolveX402Deployment({
+    network: mpp.network,
+    payTo: mpp.recipient,
+    asset: mpp.asset,
+    assetName: mpp.assetName,
+    assetVersion: mpp.assetVersion,
+    facilitator: mpp.facilitator,
+    ...mpp.allowMainnet !== void 0 ? { allowMainnet: mpp.allowMainnet } : {},
+    ...mpp.allowUnauthenticatedFacilitator !== void 0 ? { allowUnauthenticatedFacilitator: mpp.allowUnauthenticatedFacilitator } : {},
+    configPath: "payments.mpp",
+    payToField: "recipient"
+  });
+  return mpp;
+}
+function normalizeResource(id, entry, protocols, x402, mpp, ap2) {
   if (entry.input !== void 0) validateResourceSchemaKeywords(id, "input", entry.input);
   const inputProperties = entry.input?.["properties"];
   if (inputProperties && typeof inputProperties === "object") {
@@ -1247,6 +1373,7 @@ function normaliseResource(id, entry, protocols, x402, ap2) {
     );
   }
   validateBackendUrl(id, entry.backend.url);
+  validateBackendHeaders(id, entry.backend.headers);
   const pathScope = validateInputBindings(id, entry.backend, entry.input);
   validatePathParametersDeclared(id, entry.backend.url, pathScope.schema, pathScope.where);
   if (entry.pricing.type === "dynamic") {
@@ -1257,7 +1384,7 @@ function normaliseResource(id, entry, protocols, x402, ap2) {
     );
   }
   if (entry.pricing.type === "fixed") {
-    validatePricingAmount(id, entry.pricing.amount, x402);
+    validatePricingAmount(id, entry.pricing.amount, x402?.assetDecimals);
   }
   const paymentMethods = entry.payments ?? [];
   if (entry.pricing.type === "fixed") {
@@ -1272,21 +1399,32 @@ function normaliseResource(id, entry, protocols, x402, ap2) {
       if (!SUPPORTED_PAYMENT_METHODS.has(method)) {
         throw new CommerceError(
           "CONFIG_INVALID",
-          `Resource "${id}" names unsupported payment method "${method}". Supported: x402.`,
+          `Resource "${id}" names unsupported payment method "${method}". Supported: ${PAYMENT_METHOD_NAMES.join(", ")}.`,
           { details: { path: `resources.${id}.payments`, resourceId: id, method } }
         );
       }
-      if (method === "x402" && (!x402 || !x402.enabled)) {
+    }
+    const enabledRails = [...x402?.enabled ? ["x402"] : [], ...mpp?.enabled ? ["mpp"] : []];
+    if (!paymentMethods.some((method) => enabledRails.includes(method))) {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" names payment method(s) "${paymentMethods.join(", ")}", none of which is configured and enabled under "payments"`,
+        { details: { path: `resources.${id}.payments`, resourceId: id, paymentMethods } }
+      );
+    }
+    if (mpp?.enabled && paymentMethods.includes("mpp")) {
+      if (entry.pricing.currency !== MPP_PROFILE.assetSymbol) {
         throw new CommerceError(
           "CONFIG_INVALID",
-          `Resource "${id}" names payment method "x402" which is not configured or not enabled under payments.x402`,
-          { details: { path: `resources.${id}.payments`, resourceId: id, method } }
+          `Resource "${id}" is priced in ${entry.pricing.currency}, but MPP charges ${MPP_PROFILE.assetSymbol}`,
+          { details: { path: `resources.${id}.pricing.currency`, resourceId: id } }
         );
       }
+      validatePricingAmount(id, entry.pricing.amount, MPP_PROFILE.assetDecimals);
     }
   }
   const pricing = entry.pricing.type === "free" ? { type: "free" } : { type: "fixed", amount: entry.pricing.amount, currency: entry.pricing.currency };
-  const authorization = normaliseResourceAuthorization(id, entry, pricing, ap2);
+  const authorization = normalizeResourceAuthorization(id, entry, pricing, ap2);
   return {
     id,
     name: entry.name,
@@ -1316,11 +1454,11 @@ function defaultClosedObjectSchema(schema) {
   const result = { ...schema };
   if (isObjectSchema) {
     const properties = schema["properties"];
-    if (isPlainObject2(properties)) {
+    if (isRecord(properties)) {
       result["properties"] = Object.fromEntries(
         Object.entries(properties).map(([key, sub]) => [
           key,
-          isPlainObject2(sub) ? defaultClosedObjectSchema(sub) : sub
+          isRecord(sub) ? defaultClosedObjectSchema(sub) : sub
         ])
       );
     }
@@ -1329,18 +1467,15 @@ function defaultClosedObjectSchema(schema) {
     }
   }
   const items = schema["items"];
-  if (isPlainObject2(items)) {
+  if (isRecord(items)) {
     result["items"] = defaultClosedObjectSchema(items);
   }
   const additional = schema["additionalProperties"];
-  if (isPlainObject2(additional)) {
+  if (isRecord(additional)) {
     result["additionalProperties"] = defaultClosedObjectSchema(additional);
   }
   return result;
 }
-function isPlainObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function excludesObjectType(schema) {
   const type = schema["type"];
   if (type === void 0 || type === "object") return false;
@@ -1365,7 +1500,7 @@ function validateResourceSchemaKeywords(id, path2, schema) {
   const requiredRaw = schema["required"];
   const closed = !Object.hasOwn(schema, "additionalProperties") ? true : schema["additionalProperties"] === false;
   if (Array.isArray(requiredRaw) && closed && isObjectSchemaNode(schema)) {
-    const declared = isPlainObject2(schema["properties"]) ? schema["properties"] : {};
+    const declared = isRecord(schema["properties"]) ? schema["properties"] : {};
     const undeclared = requiredRaw.filter(
       (name) => typeof name === "string" && !Object.hasOwn(declared, name)
     );
@@ -1378,17 +1513,17 @@ function validateResourceSchemaKeywords(id, path2, schema) {
     }
   }
   const properties = schema["properties"];
-  if (isPlainObject2(properties)) {
+  if (isRecord(properties)) {
     for (const [key, sub] of Object.entries(properties)) {
-      if (isPlainObject2(sub)) validateResourceSchemaKeywords(id, `${path2}.properties.${key}`, sub);
+      if (isRecord(sub)) validateResourceSchemaKeywords(id, `${path2}.properties.${key}`, sub);
     }
   }
   const additional = schema["additionalProperties"];
-  if (isPlainObject2(additional)) {
+  if (isRecord(additional)) {
     validateResourceSchemaKeywords(id, `${path2}.additionalProperties`, additional);
   }
   const items = schema["items"];
-  if (isPlainObject2(items)) {
+  if (isRecord(items)) {
     validateResourceSchemaKeywords(id, `${path2}.items`, items);
   } else if (Array.isArray(items)) {
     console.warn(
@@ -1396,7 +1531,7 @@ function validateResourceSchemaKeywords(id, path2, schema) {
     );
   }
 }
-function validatePricingAmount(id, amount, x402) {
+function validatePricingAmount(id, amount, decimals) {
   const path2 = `resources.${id}.pricing.amount`;
   if (!PRICING_AMOUNT_PATTERN.test(amount)) {
     throw new CommerceError(
@@ -1412,12 +1547,12 @@ function validatePricingAmount(id, amount, x402) {
       { details: { path: path2, resourceId: id } }
     );
   }
-  if (x402 !== void 0) {
+  if (decimals !== void 0) {
     const fractionalDigits = amount.includes(".") ? amount.split(".")[1]?.length ?? 0 : 0;
-    if (fractionalDigits > x402.assetDecimals) {
+    if (fractionalDigits > decimals) {
       throw new CommerceError(
         "CONFIG_INVALID",
-        `Resource "${id}" has pricing.amount "${amount}" with more precision (${fractionalDigits} fractional digits) than the configured asset supports (${x402.assetDecimals} decimals)`,
+        `Resource "${id}" has pricing.amount "${amount}" with more precision (${fractionalDigits} fractional digits) than the configured asset supports (${decimals} decimals)`,
         { details: { path: path2, resourceId: id } }
       );
     }
@@ -1453,7 +1588,7 @@ function validateInputBindings(id, backend, input) {
     );
   }
   const seen = /* @__PURE__ */ new Map();
-  const properties = isPlainObject2(input?.["properties"]) ? input["properties"] : {};
+  const properties = isRecord(input?.["properties"]) ? input["properties"] : {};
   const required = new Set(
     Array.isArray(input?.["required"]) ? input["required"].filter((value) => typeof value === "string") : []
   );
@@ -1476,7 +1611,7 @@ function validateInputBindings(id, backend, input) {
       );
     }
     const declared = properties[property];
-    if (location !== "body" && isPlainObject2(declared) && !isObjectSchemaNode(declared)) {
+    if (location !== "body" && isRecord(declared) && !isObjectSchemaNode(declared)) {
       fail(
         `binds "${location}" to input property "${property}", which is not an object schema - ${location} parameters are read as an object of name/value pairs`,
         { location, property }
@@ -1492,7 +1627,7 @@ function validateInputBindings(id, backend, input) {
   if (bindings.path === void 0) return { schema: void 0, where: "its input schema" };
   const group = properties[bindings.path];
   return {
-    schema: isPlainObject2(group) ? group : void 0,
+    schema: isRecord(group) ? group : void 0,
     where: `input.properties.${bindings.path}`
   };
 }
@@ -1504,7 +1639,7 @@ function validatePathParametersDeclared(id, url, input, where) {
   if (stray !== void 0) {
     throw new CommerceError(
       "CONFIG_INVALID",
-      `Resource "${id}" has backend.url containing "${stray}", which is not a valid path parameter (allowed characters: A-Z a-z 0-9 _ . -). It would be sent to the backend literally, so a paid resource would settle payment and then never reach the backend`,
+      `Resource "${id}" has backend.url containing "${stray}", which is not a valid path parameter (allowed characters: A-Z a-z 0-9 _ . -). It would reach the backend as literal text, so a paid resource would take payment for a request the backend cannot serve`,
       { details: { path: `resources.${id}.backend.url`, resourceId: id, token: stray } }
     );
   }
@@ -1522,13 +1657,13 @@ function validatePathParametersDeclared(id, url, input, where) {
     if (origin === void 0 || !prefix.startsWith(`${origin}/`)) {
       throw new CommerceError(
         "CONFIG_INVALID",
-        `Resource "${id}" has a backend.url parameter before the end of the host ("${url}"). A caller-supplied value would choose which host the gateway calls, which is request forgery with the gateway's own network position. Parameters are supported inside the path and query only`,
+        `Resource "${id}" has a backend.url parameter before the end of the host. A caller-supplied value would choose which host the gateway calls, which is request forgery with the gateway's own network position. Parameters are supported inside the path and query only`,
         { details: { path: `resources.${id}.backend.url`, resourceId: id } }
       );
     }
   }
   const propertiesRaw = input?.["properties"];
-  const properties = isPlainObject2(propertiesRaw) ? propertiesRaw : {};
+  const properties = isRecord(propertiesRaw) ? propertiesRaw : {};
   const requiredRaw = input?.["required"];
   const required = new Set(
     Array.isArray(requiredRaw) ? requiredRaw.filter((entry) => typeof entry === "string") : []
@@ -1538,14 +1673,14 @@ function validatePathParametersDeclared(id, url, input, where) {
     if (!Object.hasOwn(properties, param)) {
       throw new CommerceError(
         "CONFIG_INVALID",
-        `Resource "${id}" has backend.url path parameter "{${param}}" which is not declared in ${where} - the caller has no way to supply it, so every call would settle payment (if priced) and then fail to reach the backend`,
+        `Resource "${id}" has backend.url path parameter "{${param}}" which is not declared in ${where} - the caller has no way to supply it, so every call would be refused`,
         { details: { path: path2, resourceId: id, param } }
       );
     }
     if (!required.has(param)) {
       throw new CommerceError(
         "CONFIG_INVALID",
-        `Resource "${id}" has backend.url path parameter "{${param}}" declared in ${where} but not listed in its "required" - a caller that omits it hits the same unservable-request problem as an undeclared parameter`,
+        `Resource "${id}" has backend.url path parameter "{${param}}" declared in ${where} but not listed in its "required" - a call that omits it would be refused`,
         { details: { path: path2, resourceId: id, param } }
       );
     }
@@ -1558,7 +1693,7 @@ function validateBackendUrl(id, url) {
   } catch {
     throw new CommerceError(
       "CONFIG_INVALID",
-      `Resource "${id}" has an invalid backend.url "${url}": must be an absolute http:// or https:// URL`,
+      `Resource "${id}" has an invalid backend.url: must be an absolute http:// or https:// URL`,
       { details: { path: `resources.${id}.backend.url`, resourceId: id } }
     );
   }
@@ -1570,6 +1705,19 @@ function validateBackendUrl(id, url) {
     );
   }
 }
+function validateBackendHeaders(id, headers) {
+  for (const [name, value] of Object.entries(headers ?? {})) {
+    try {
+      new Headers([[name, value]]);
+    } catch {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `Resource "${id}" has backend header "${name}" with an illegal name or value (a name must be an HTTP token; a value must not contain NUL, a character above U+00FF, or a line break except at either end, which fetch trims)`,
+        { details: { path: `resources.${id}.backend.headers.${name}`, resourceId: id } }
+      );
+    }
+  }
+}
 function validateAddress(path2, value) {
   if (!ADDRESS_PATTERN.test(value)) {
     throw new CommerceError(
@@ -1588,19 +1736,21 @@ function validateAddress(path2, value) {
     );
   }
 }
-var SUPPORTED_CONFIG_VERSION, ADDRESS_PATTERN, ZERO_ADDRESS_PATTERN, MCP_TOOL_NAME_PATTERN, NumberOrString, BooleanOrString, MerchantSchema, ServerSchema, StorageSchema, RESERVED_GATEWAY_PATHS, MountPathSchema, AcpAuthSchema, AcpIdempotencySchema, AcpCheckoutSchema, AcpDiscoverySchema, ProtocolsSchema, DEFAULT_A2A_MOUNT_PATH, DEFAULT_ACP_MOUNT_PATH, ACP_RETENTION_HOURS, BackendMethodSchema, BackendInputBindingsSchema, BackendHandlerSchema, PricingSchema, JsonSchemaValueSchema, ResourceEntrySchema, ResourcesMapSchema, FacilitatorAuthSchema, FacilitatorSchema, X402Schema, PaymentsSchema, Ap2KeySchema, Ap2IssuerSchema, Ap2Schema, AuthorizationSchema, RawConfigSchema, SUPPORTED_PROTOCOLS, SUPPORTED_PAYMENT_METHODS, SUPPORTED_AUTHORIZATION_METHODS, EMPTY_CLOSED_OBJECT_SCHEMA, UNSUPPORTED_SCHEMA_KEYWORDS, PRICING_AMOUNT_PATTERN, ZERO_AMOUNT_PATTERN;
+var SUPPORTED_CONFIG_VERSION, ADDRESS_PATTERN, ZERO_ADDRESS_PATTERN, NumberOrString, BooleanOrString, MerchantSchema, ServerSchema, StorageSchema, RESERVED_GATEWAY_PATHS, MountPathSchema, AcpAuthSchema, AcpIdempotencySchema, AcpCheckoutSchema, AcpDiscoverySchema, ProtocolsSchema, DEFAULT_A2A_MOUNT_PATH, DEFAULT_ACP_MOUNT_PATH, ACP_RETENTION_HOURS, BackendMethodSchema, BackendInputBindingsSchema, BackendHandlerSchema, PricingSchema, JsonSchemaValueSchema, ResourceEntrySchema, ResourcesMapSchema, FacilitatorAuthSchema, FacilitatorSchema, X402Schema, MppSchema, PaymentsSchema, Ap2KeySchema, Ap2IssuerSchema, Ap2Schema, AuthorizationSchema, RawConfigSchema, SUPPORTED_PROTOCOLS, SUPPORTED_PAYMENT_METHODS, SUPPORTED_AUTHORIZATION_METHODS, EMPTY_CLOSED_OBJECT_SCHEMA, UNSUPPORTED_SCHEMA_KEYWORDS, PRICING_AMOUNT_PATTERN, ZERO_AMOUNT_PATTERN;
 var init_schema = __esm({
   "src/config/schema.ts"() {
     init_constants();
-    init_execution();
     init_core();
-    init_guardrails();
+    init_execution();
+    init_is_record();
     init_constants2();
+    init_guardrails();
+    init_constants3();
+    init_constants4();
     init_env();
     SUPPORTED_CONFIG_VERSION = 1;
     ADDRESS_PATTERN = /^0x[0-9a-fA-F]{40}$/;
     ZERO_ADDRESS_PATTERN = /^0x0{40}$/i;
-    MCP_TOOL_NAME_PATTERN = /^[A-Za-z0-9._-]{1,128}$/;
     NumberOrString = z.union([z.number(), z.string()]);
     BooleanOrString = z.union([z.boolean(), z.string()]);
     MerchantSchema = z.object({
@@ -1611,14 +1761,14 @@ var init_schema = __esm({
     ServerSchema = z.object({
       port: NumberOrString,
       host: z.string().min(1),
-      /** Shared secret gating /api/receipts, /api/events, /api/events/stream. No token -> those routes 404. */
+      // Shared secret gating /api/receipts and /api/events. Without it both
+      // routes 404.
       adminToken: z.string().min(1).optional(),
-      /** Browser origins allowed to read the dashboard-facing routes. Empty by default: closed. */
-      // Entries are matched literally against the browser's
-      // `Origin` header, so `"*"` and a trailing slash match nothing at all -
-      // fail-closed (a lockout, not a bypass), but silently, and a lockout with
-      // no explanation is the kind of thing an operator "fixes" by disabling the
-      // check. Reject those two shapes with a pointer instead.
+      // Browser origins allowed to call the gateway; none by default. A request
+      // with any other `Origin` gets 403 on every route. Entries match the
+      // `Origin` header exactly (ignoring case), so `"*"` and a trailing slash
+      // would match nothing: a silent lockout that an operator might "fix" by
+      // disabling the check. Both are refused with a pointer.
       allowedOrigins: z.array(
         z.string().min(1).refine((origin) => origin !== "*", {
           message: `wildcard "*" is not supported - allowedOrigins entries are matched literally against the browser's Origin header, so "*" would match nothing. List each scheme://host[:port] explicitly.`
@@ -1637,16 +1787,14 @@ var init_schema = __esm({
       "/health",
       "/ready",
       "/.well-known/agent-commerce",
-      // Fixed by the A2A specification, so it is the adapter's to serve and never
-      // a configurable mount's to claim.
+      // Fixed by the A2A specification and served by the adapter
       "/.well-known/agent-card.json",
-      // Likewise fixed by the ACP specification.
+      // Fixed by the ACP specification
       ACP_WELL_KNOWN_PATH,
       "/api/resources",
       "/api/resources/:id/invoke",
       "/api/receipts",
-      "/api/events",
-      "/api/events/stream"
+      "/api/events"
     ];
     MountPathSchema = z.string().min(1).refine((value) => value.startsWith("/"), {
       message: 'must start with "/" - it is an absolute gateway path, e.g. "/mcp".'
@@ -1678,16 +1826,14 @@ var init_schema = __esm({
         enabled: BooleanOrString,
         mountPath: MountPathSchema
       }).strict(),
-      // Optional block: A2A is off unless an operator asks for it, and an
-      // existing config predating the adapter stays valid.
+      // Optional; A2A is off unless configured
       a2a: z.object({
         enabled: BooleanOrString,
         mountPath: MountPathSchema.optional()
       }).strict().optional(),
-      // Likewise optional and off by default. The sub-blocks are optional here
-      // and required by the business pass only when ACP is enabled, so a
-      // disabled placeholder block stays writable and an enabled one gets a
-      // message naming the piece it is missing.
+      // Optional and off by default. The business pass requires the sub-blocks
+      // only when ACP is enabled, so a disabled placeholder stays valid and an
+      // enabled block gets a message naming what it lacks.
       acp: z.object({
         enabled: BooleanOrString,
         mountPath: MountPathSchema.optional(),
@@ -1743,7 +1889,7 @@ var init_schema = __esm({
       z.object({ type: z.literal("none") }).strict(),
       z.object({ type: z.literal("bearer"), token: z.string().min(1) }).strict(),
       // Coinbase Developer Platform. Needs the optional peer `@coinbase/x402`,
-      // which signs a fresh JWT per request; a static header cannot express it.
+      // which signs a fresh JWT per request.
       z.object({
         type: z.literal("cdp"),
         apiKeyId: z.string().min(1),
@@ -1758,10 +1904,8 @@ var init_schema = __esm({
       z.object({
         mode: z.literal("remote"),
         url: z.string().min(1),
-        // Absent means "this facilitator takes no credential" - an explicit
-        // statement, normalised to `{ type: 'none' }` below. On a mainnet that
-        // combination is refused outright, so the default can never quietly
-        // become an unauthenticated production facilitator.
+        // Absent auth sends no credential and normalizes to `{ type: 'none' }`,
+        // which on mainnet requires `allowUnauthenticatedFacilitator`
         auth: FacilitatorAuthSchema.optional()
       }).strict()
     ]);
@@ -1776,13 +1920,31 @@ var init_schema = __esm({
       payTo: z.string().min(1),
       maxTimeoutSeconds: NumberOrString,
       facilitator: FacilitatorSchema,
-      /** Real funds. Never defaulted - see src/payments/x402/guardrails.ts. */
+      // Real funds. Never defaulted; see src/payments/x402/guardrails.ts
+      allowMainnet: BooleanOrString.optional(),
+      // Accepts credential-free facilitator access on mainnet. Never defaulted
+      allowUnauthenticatedFacilitator: BooleanOrString.optional()
+    }).strict();
+    MppSchema = z.object({
+      enabled: BooleanOrString,
+      network: z.string().min(1).optional(),
+      rpcUrl: z.string().min(1),
+      asset: z.string().min(1),
+      assetName: z.string().min(1),
+      assetVersion: z.string().min(1),
+      recipient: z.string().min(1),
+      realm: z.string().min(1),
+      challengeSecret: z.string().min(1),
+      challengeTtlSeconds: NumberOrString.optional(),
+      facilitator: FacilitatorSchema,
+      // Real funds. Never defaulted; see src/payments/x402/guardrails.ts
       allowMainnet: BooleanOrString.optional(),
-      /** Accepts a mainnet facilitator that takes no credential. Never defaulted. */
+      // Accepts credential-free facilitator access on mainnet. Never defaulted
       allowUnauthenticatedFacilitator: BooleanOrString.optional()
     }).strict();
     PaymentsSchema = z.object({
-      x402: X402Schema.optional()
+      x402: X402Schema.optional(),
+      mpp: MppSchema.optional()
     }).strict();
     Ap2KeySchema = z.object({
       kid: z.string().min(1),
@@ -1790,11 +1952,8 @@ var init_schema = __esm({
     }).strict();
     Ap2IssuerSchema = z.object({
       issuer: z.string().min(1),
-      /**
-       * Required, not defaulted. Without it, a mandate minted for another
-       * merchant would verify here, and there is no value worth guessing for
-       * something that decides that.
-       */
+      // Required, not defaulted: without it a mandate minted for another
+      // merchant would verify here
       audience: z.string().min(1),
       keys: z.array(Ap2KeySchema).min(1)
     }).strict();
@@ -1821,7 +1980,7 @@ var init_schema = __esm({
       authorization: AuthorizationSchema.optional()
     }).strict();
     SUPPORTED_PROTOCOLS = new Set(PROTOCOL_NAMES);
-    SUPPORTED_PAYMENT_METHODS = /* @__PURE__ */ new Set(["x402"]);
+    SUPPORTED_PAYMENT_METHODS = new Set(PAYMENT_METHOD_NAMES);
     SUPPORTED_AUTHORIZATION_METHODS = /* @__PURE__ */ new Set(["ap2"]);
     EMPTY_CLOSED_OBJECT_SCHEMA = {
       type: "object",
@@ -1876,9 +2035,8 @@ async function loadConfig(options = {}) {
       `Configuration file "${configPath}" is not valid YAML: ${reason}`,
       {
         details: { path: configPath, ...details },
-        // Retained for programmatic callers. Nothing in the CLI prints a
-        // `cause`, and nothing should start: this is the object whose
-        // `.message` carries the source excerpt (see below).
+        // Kept for programmatic callers. Never print it: its `.message` quotes
+        // the source line (see describeYamlError).
         cause: error
       }
     );
@@ -1949,9 +2107,9 @@ init_core();
 function defaultDemoSteps() {
   return [
     {
-      name: "Start local chain + gateway + merchant (docker compose)",
+      name: "Start the local stack: chain, merchant, gateway and dashboard (docker compose)",
       command: "docker",
-      args: ["compose", "up", "--build", "-d"]
+      args: ["compose", "up", "--build", "--detach", "--wait"]
     },
     { name: "Run the deterministic buyer agent", command: "npm", args: ["run", "demo:agent"] }
   ];
@@ -1959,7 +2117,7 @@ function defaultDemoSteps() {
 async function runDemo(io, deps = {}) {
   const steps = deps.steps ?? defaultDemoSteps();
   const run = deps.run ?? execCommand;
-  io.stdout("agent-commerce demo \u2014 running the documented quickstart steps:");
+  io.stdout("agent-commerce demo: starting the local stack, then running the buyer agent");
   for (const step of steps) {
     io.stdout("");
     io.stdout(`==> ${step.name}`);
@@ -1975,13 +2133,6 @@ async function runDemo(io, deps = {}) {
       io.stderr(`  ${step.command} ${step.args.join(" ")}`);
       return 1;
     }
-    if (step.healthCheck !== void 0) {
-      const healthy = await step.healthCheck();
-      if (!healthy) {
-        io.stderr(`FAIL  "${step.name}" completed but its health check did not pass.`);
-        return 1;
-      }
-    }
     io.stdout(`OK    ${step.name}`);
   }
   io.stdout("");
@@ -2012,8 +2163,7 @@ init_constants();
 // src/authorization/ap2/descriptor.ts
 init_constants();
 var AP2_UNSUPPORTED = [
-  // Mandate kinds. Open mandates carry spending constraints nothing here
-  // evaluates, so accepting one would tell a buyer their limits were checked.
+  // Mandate kinds. Open mandates are refused: see AP2_CHECKOUT_MANDATE_VCT
   "autonomous mode",
   "open checkout mandates (mandate.checkout.open.1)",
   "intent mandates",
@@ -2029,13 +2179,13 @@ var AP2_UNSUPPORTED = [
   "digest algorithms other than sha-256",
   // Roles this gateway does not play
   "mandate issuance",
-  "merchant checkout JWT issuance",
   "AP2 over the ACP checkout adapter"
 ];
 
 // src/cli/commands/doctor.ts
-init_execution();
 init_core();
+init_execution();
+init_constants2();
 init_networks();
 
 // src/protocols/a2a/constants.ts
@@ -2058,13 +2208,12 @@ var A2A_UNSUPPORTED_METHODS = [
 
 // src/protocols/a2a/descriptor.ts
 var A2A_UNSUPPORTED = [
-  // Methods, named as the protocol names them. Same list the transport
-  // rejects by name, so the descriptor cannot promise less than it refuses.
+  // Methods, as the protocol names them; the transport refuses the same list
   ...A2A_UNSUPPORTED_METHODS,
-  // Transports other than the one binding served.
+  // Transports other than the one binding served
   "HTTP+JSON/REST binding",
   "gRPC binding",
-  // Behaviours.
+  // Behaviors
   "SSE",
   "long-running task persistence",
   "task resumption",
@@ -2076,10 +2225,10 @@ var A2A_UNSUPPORTED = [
 ];
 
 // src/cli/commands/doctor.ts
-init_constants2();
+init_constants3();
 
 // src/protocols/acp/descriptor.ts
-init_constants2();
+init_constants3();
 [
   "rest transport",
   "well-known discovery",
@@ -2096,15 +2245,15 @@ var ACP_UNSUPPORTED = [
   "standalone orders service",
   "delegate_payment",
   "delegate_authentication",
-  // Bindings and delivery directions.
+  // Bindings and delivery directions
   "ACP MCP transport binding",
   "webhooks",
   "outbound merchant-to-agent delivery",
   "ACP client role",
-  // Request authentication beyond the bearer token.
+  // Request authentication beyond the bearer token
   "Signature header verification",
   "Timestamp replay-window verification",
-  // Extensions and versioning.
+  // Extensions, versioning and payment handlers
   "discount extension",
   "general ACP extension framework",
   "multiple ACP API versions",
@@ -2113,7 +2262,7 @@ var ACP_UNSUPPORTED = [
 
 // src/storage/receipts/store.ts
 init_core();
-var PACKAGE_VERSION = "1.4.1" ;
+var PACKAGE_VERSION = "1.6.0" ;
 
 // src/storage/sqlite.ts
 init_core();
@@ -2121,10 +2270,7 @@ function openSqliteDatabase(options) {
   const { path: path2, label, logger } = options;
   const isFileBacked = path2 !== ":memory:";
   if (isFileBacked) {
-    const dir = dirname(path2);
-    if (dir !== "" && dir !== "." && !existsSync(dir)) {
-      mkdirSync(dir, { recursive: true, mode: 448 });
-    }
+    mkdirSync(dirname(path2), { recursive: true, mode: 448 });
   }
   if (isFileBacked && existsSync(path2)) {
     try {
@@ -2196,8 +2342,8 @@ function receiptToRow(receipt) {
     payment_json: receipt.payment !== void 0 ? JSON.stringify(redact(receipt.payment)) : null,
     delivered_at: receipt.deliveredAt,
     backend_status: receipt.backendStatus,
-    duration_ms: receipt.durationMs !== void 0 ? receipt.durationMs : null,
-    protocol: receipt.protocol !== void 0 ? receipt.protocol : null,
+    duration_ms: receipt.durationMs ?? null,
+    protocol: receipt.protocol ?? null,
     metadata_json: receipt.metadata !== void 0 ? JSON.stringify(redact(receipt.metadata)) : null,
     authorization_json: receipt.authorization !== void 0 ? JSON.stringify(redact(receipt.authorization)) : null
   };
@@ -2224,12 +2370,12 @@ function eventToRow(event) {
     id: event.id,
     type: event.type,
     request_id: event.requestId,
-    resource_id: event.resourceId !== void 0 ? event.resourceId : null,
+    resource_id: event.resourceId ?? null,
     at: event.at,
-    adapter: event.adapter !== void 0 ? event.adapter : null,
-    payment_provider: event.paymentProvider !== void 0 ? event.paymentProvider : null,
-    duration_ms: event.durationMs !== void 0 ? event.durationMs : null,
-    status: event.status !== void 0 ? event.status : null,
+    adapter: event.adapter ?? null,
+    payment_provider: event.paymentProvider ?? null,
+    duration_ms: event.durationMs ?? null,
+    status: event.status ?? null,
     data_json: event.data !== void 0 ? JSON.stringify(redact(event.data)) : null
   };
 }
@@ -2333,7 +2479,7 @@ var MIGRATIONS = [
     }
   }
 ];
-var SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
+var SCHEMA_VERSION = MIGRATIONS.at(-1)?.version ?? 0;
 function migrate(db) {
   const current = db.pragma("user_version", { simple: true });
   for (const migration of MIGRATIONS) {
@@ -2396,10 +2542,8 @@ function createSqliteReceiptStore(options) {
   );
   const insertPaymentAttemptStmt = db.prepare(
     `INSERT INTO payment_attempts (id, request_id, resource_id, provider, replay_key, status, amount, currency, payer, payee, external_reference, rejection_reason, created_at, updated_at)
-     VALUES (@id, @request_id, @resource_id, @provider, @replay_key, @status, @amount, @currency, @payer, @payee, @external_reference, @rejection_reason, @created_at, @updated_at)`
-  );
-  const getPaymentAttemptByIdStmt = db.prepare(
-    "SELECT * FROM payment_attempts WHERE id = ?"
+     VALUES (@id, @request_id, @resource_id, @provider, @replay_key, @status, @amount, @currency, @payer, @payee, @external_reference, @rejection_reason, @created_at, @updated_at)
+     RETURNING *`
   );
   const updatePaymentAttemptStmt = db.prepare(
     `UPDATE payment_attempts SET status = @status,
@@ -2450,8 +2594,9 @@ function createSqliteReceiptStore(options) {
     async reservePaymentAttempt(reservation) {
       const now = clock.nowIso();
       const id = ids.next("attempt");
+      let row;
       try {
-        insertPaymentAttemptStmt.run({
+        row = insertPaymentAttemptStmt.get({
           id,
           request_id: reservation.requestId,
           resource_id: reservation.resourceId,
@@ -2471,19 +2616,12 @@ function createSqliteReceiptStore(options) {
         if (isUniqueConstraintOn(err, "payment_attempts.replay_key")) {
           throw new CommerceError(
             "PAYMENT_REPLAYED",
-            `Payment authorisation has already been used (replayKey=${reservation.replayKey})`,
+            `Payment authorization has already been used (replayKey=${reservation.replayKey})`,
             { requestId: reservation.requestId, resourceId: reservation.resourceId }
           );
         }
         throw toCommerceError(err, "STORAGE_ERROR", "Failed to reserve payment attempt");
       }
-      const row = getPaymentAttemptByIdStmt.get(id);
-      if (row === void 0) {
-        throw new CommerceError(
-          "STORAGE_ERROR",
-          "Payment attempt vanished immediately after insert"
-        );
-      }
       return rowToPaymentAttempt(row);
     },
     async updatePaymentAttempt(update) {
@@ -2521,11 +2659,11 @@ function createSqliteReceiptStore(options) {
       const rows = listOptions.requestId !== void 0 ? listReceiptsByRequestStmt.all(listOptions.requestId, limit) : listReceiptsStmt.all(limit);
       return rows.map(rowToReceipt);
     },
-    /** Exact total, ignoring the listReceipts clamp — see the interface doc for why this exists. */
+    // Exact total, not bounded by the listReceipts clamp (see ReceiptStore.countReceipts)
     async countReceipts() {
       return countReceiptsStmt.get()?.count ?? 0;
     },
-    /** Exact count of non-2xx receipts — see the interface doc for why this exists. */
+    // Exact count of non-2xx receipts (see ReceiptStore.countUndeliveredReceipts)
     async countUndeliveredReceipts() {
       return countUndeliveredReceiptsStmt.get()?.count ?? 0;
     },
@@ -2605,35 +2743,28 @@ function createSqliteReceiptStore(options) {
 }
 
 // src/cli/lib/config-client.ts
-async function loadConfigDynamic(options = {}) {
-  let mod;
+init_core();
+async function importConfig() {
   try {
-    mod = await Promise.resolve().then(() => (init_config(), config_exports));
+    return await Promise.resolve().then(() => (init_config(), config_exports));
   } catch (err) {
-    throw new Error(
+    throw new CommerceError(
+      "INTERNAL_ERROR",
       `the configuration module could not be loaded: ${err instanceof Error ? err.message : String(err)}`
     );
   }
-  return mod.loadConfig(options);
+}
+async function loadConfigDynamic(options = {}) {
+  return (await importConfig()).loadConfig(options);
 }
 async function parseConfigDynamic(raw, env = process.env) {
-  let mod;
-  try {
-    mod = await Promise.resolve().then(() => (init_config(), config_exports));
-  } catch (err) {
-    throw new Error(
-      `the configuration module could not be loaded: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  return mod.parseConfig(raw, env);
+  return (await importConfig()).parseConfig(raw, env);
 }
 
 // src/cli/lib/http.ts
 async function fetchJson(fetchImpl, url, timeoutMs = 1500) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    const res = await fetchImpl(url, { signal: controller.signal });
+    const res = await fetchImpl(url, { signal: AbortSignal.timeout(timeoutMs) });
     let body;
     try {
       body = await res.json();
@@ -2647,8 +2778,6 @@ async function fetchJson(fetchImpl, url, timeoutMs = 1500) {
       status: 0,
       error: err instanceof Error ? err.message : "unknown fetch error"
     };
-  } finally {
-    clearTimeout(timer);
   }
 }
 
@@ -2693,9 +2822,8 @@ function buildResourcesMap(answers) {
     resources.report = {
       name: "Get market report",
       description: "Deterministic demo premium market report.",
-      // No caller-supplied fields for this resource: an explicit empty,
-      // closed schema (rather than omitting `input`) so a missing schema can
-      // never be read as "anything goes".
+      // No caller-supplied fields. Config loads a missing `input` as this same
+      // closed schema; writing it out shows that in the generated file
       input: {
         type: "object",
         properties: {},
@@ -2746,25 +2874,22 @@ function buildInitConfigObject(answers) {
 }
 var HEADER = `# Generated by \`agent-commerce init\`.
 #
-# Any address/key below labelled "LOCAL DEVELOPMENT ONLY" or "placeholder" is
-# either one of Anvil's well-known, public dev accounts (never fund them,
-# never use them outside a local chain) or a
-# not-yet-real address. Before running against the local chain, run
-# \`npm run chain:deploy\` and replace \`payments.x402.asset\` with the deployed
-# MockUSDC address from \`.deploy/local.json\`. Replace \`payments.x402.payTo\`
-# with your real merchant-controlled settlement address before ever pointing
-# this at a funded network.
+# With x402 enabled, the facilitator signerPrivateKey is Anvil's public dev
+# account #0 and the default payTo is account #1.
+# LOCAL DEVELOPMENT ONLY - DO NOT FUND: never use them outside a local chain.
+# payments.x402.asset is a placeholder, not a real contract. Before running
+# against the local chain, run \`npm run chain:deploy\` and set it to the
+# MockUSDC address in \`.deploy/local.json\`. Before pointing this at a funded
+# network, set \`payments.x402.payTo\` to your own settlement address.
 #
-# server.host is loopback (127.0.0.1) on purpose: binding every interface
-# should be a deliberate edit, not something you inherit from a generator.
+# server.host is loopback (127.0.0.1): binding every interface should be a
+# deliberate edit.
 #
-# server.adminToken / server.allowedOrigins are left unset here \u2014 a generated
-# secret in a file you might commit is its own problem, so this is left as a
-# placeholder for you to fill in rather than a real token. Without a token,
-# the operator routes (/api/receipts, /api/events, /api/events/stream) \u2014
-# the merchant's commerce ledger: payer addresses, amounts, settlement
-# hashes \u2014 return 404 rather than serving openly. To enable them, uncomment
-# and set:
+# server.adminToken and server.allowedOrigins are left unset, so no secret
+# lands in a file you might commit. Without a token the operator routes
+# (/api/receipts, /api/events) return 404. They serve the merchant's commerce
+# ledger: payer addresses, amounts and settlement hashes. To enable them, add
+# these keys to the server block below:
 #   server:
 #     adminToken: \${ADMIN_TOKEN}
 #     allowedOrigins:
@@ -2776,18 +2901,30 @@ function renderInitConfigYaml(answers) {
   return `${HEADER}
 ${body}`;
 }
+
+// src/payments/x402/local-chain/manifest.ts
+init_core();
 var LOCAL_CHAIN_MANIFEST_PATH = ".deploy/local.json";
-var REQUIRED_TOP_LEVEL_STRING_FIELDS = [
-  "rpcUrl",
-  "asset",
-  "assetName",
-  "assetVersion",
-  "buyerInitialBalance"
-];
+var nonEmpty = z.string().min(1, "must be a non-empty string");
+var keyedAccount = z.object({ address: z.string(), privateKey: z.string(), note: z.string() });
+var MANIFEST_SCHEMA = z.object({
+  chainId: z.number(),
+  rpcUrl: nonEmpty,
+  hostRpcUrl: nonEmpty.optional(),
+  asset: nonEmpty,
+  assetName: nonEmpty,
+  assetVersion: nonEmpty,
+  assetDecimals: z.number(),
+  merchant: z.object({ address: z.string(), privateKeyLabel: z.string() }),
+  buyer: keyedAccount,
+  facilitator: keyedAccount,
+  buyerInitialBalance: nonEmpty
+});
 function readLocalChainManifest(cwd = process.cwd()) {
   const path2 = join(cwd, LOCAL_CHAIN_MANIFEST_PATH);
   if (!existsSync(path2)) {
-    throw new Error(
+    throw new CommerceError(
+      "CONFIG_INVALID",
       `Local chain manifest not found at "${path2}". Run "npm run chain:start" then "npm run chain:deploy" first.`
     );
   }
@@ -2795,56 +2932,30 @@ function readLocalChainManifest(cwd = process.cwd()) {
   try {
     raw = readFileSync(path2, "utf8");
   } catch (cause) {
-    throw new Error(`Could not read local chain manifest at "${path2}".`, { cause });
+    throw new CommerceError("CONFIG_INVALID", `Could not read local chain manifest at "${path2}".`, {
+      cause
+    });
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch (cause) {
-    throw new Error(
+    throw new CommerceError(
+      "CONFIG_INVALID",
       `Local chain manifest at "${path2}" is not valid JSON. Re-run "npm run chain:deploy" to regenerate it.`,
       { cause }
     );
   }
-  return validateManifestShape(parsed, path2);
-}
-function validateManifestShape(value, path2) {
-  const fail = (detail) => {
-    throw new Error(
-      `Local chain manifest at "${path2}" is invalid: ${detail}. Re-run "npm run chain:deploy".`
+  const result = MANIFEST_SCHEMA.safeParse(parsed);
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    const where = issue?.path.length ? `${issue.path.join(".")}: ` : "";
+    throw new CommerceError(
+      "CONFIG_INVALID",
+      `Local chain manifest at "${path2}" is invalid: ${where}${issue?.message ?? "unexpected shape"}. Re-run "npm run chain:deploy".`
     );
-  };
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return fail("expected a JSON object");
-  }
-  const record = value;
-  if (typeof record.chainId !== "number") {
-    return fail('"chainId" must be a number');
   }
-  if (typeof record.assetDecimals !== "number") {
-    return fail('"assetDecimals" must be a number');
-  }
-  for (const field of REQUIRED_TOP_LEVEL_STRING_FIELDS) {
-    if (typeof record[field] !== "string" || record[field] === "") {
-      return fail(`"${field}" must be a non-empty string`);
-    }
-  }
-  if ("hostRpcUrl" in record && record.hostRpcUrl !== void 0) {
-    if (typeof record.hostRpcUrl !== "string" || record.hostRpcUrl === "") {
-      return fail('"hostRpcUrl" must be a non-empty string when present');
-    }
-  }
-  const merchant = record.merchant;
-  if (typeof merchant !== "object" || merchant === null || typeof merchant.address !== "string" || typeof merchant.privateKeyLabel !== "string") {
-    return fail('"merchant" must be { address: string, privateKeyLabel: string }');
-  }
-  for (const key of ["buyer", "facilitator"]) {
-    const account = record[key];
-    if (typeof account !== "object" || account === null || typeof account.address !== "string" || typeof account.privateKey !== "string" || typeof account.note !== "string") {
-      return fail(`"${key}" must be { address: string, privateKey: string, note: string }`);
-    }
-  }
-  return record;
+  return result.data;
 }
 
 // src/cli/lib/manifest-env.ts
@@ -2882,12 +2993,63 @@ function maskMiddle(value, keep = 6) {
   if (value.length <= keep * 2) return value.length === 0 ? value : "\u2026";
   return `${value.slice(0, keep)}\u2026${value.slice(-4)}`;
 }
-createRequire(import.meta.url);
+
+// package.json
+var package_default = {
+  dependencies: {
+    "@clack/prompts": "1.7.0",
+    "@scalar/openapi-parser": "0.29.0",
+    ajv: "8.20.0",
+    "ajv-formats": "3.0.1",
+    "better-sqlite3": "13.0.3",
+    commander: "15.0.0",
+    fastify: "5.12.0",
+    picocolors: "1.1.1",
+    pino: "10.3.1",
+    yaml: "2.9.0",
+    zod: "3.25.76"
+  },
+  peerDependencies: {
+    "@coinbase/x402": "2.1.0",
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "@sd-jwt/core": "0.20.1",
+    "@x402/core": "2.23.0",
+    "@x402/evm": "2.23.0",
+    canonicalize: "5.0.0",
+    jose: "6.2.12",
+    mppx: "0.10.1",
+    viem: "2.55.18"
+  }};
+
+// src/cli/lib/versions.ts
+var PINS = [
+  ["@modelcontextprotocol/sdk", "protocols/mcp"],
+  ["ajv", "protocols/acp"],
+  ["ajv-formats", "protocols/acp"],
+  ["@x402/core", "payments/x402"],
+  ["@x402/evm", "payments/x402"],
+  ["@coinbase/x402", "payments/x402"],
+  ["viem", "payments/x402"],
+  ["mppx", "payments/mpp"],
+  ["jose", "authorization/ap2"],
+  ["@sd-jwt/core", "authorization/ap2"],
+  ["canonicalize", "authorization/ap2"],
+  ["@scalar/openapi-parser", "openapi"],
+  ["zod", "config"],
+  ["fastify", "gateway"],
+  ["pino", "gateway"],
+  ["better-sqlite3", "storage"]
+];
 function readVersionReport() {
-  const injected = '{"cliVersion":"1.4.1","pinned":[{"name":"@coinbase/x402","version":"2.1.0","via":"@devlab.group/agent-commerce"},{"name":"@modelcontextprotocol/sdk","version":"1.30.0","via":"@devlab.group/agent-commerce"},{"name":"@x402/core","version":"2.23.0","via":"@devlab.group/agent-commerce"},{"name":"@x402/evm","version":"2.23.0","via":"@devlab.group/agent-commerce"},{"name":"viem","version":"2.55.18","via":"@devlab.group/agent-commerce"},{"name":"better-sqlite3","version":"13.0.3","via":"@devlab.group/agent-commerce"},{"name":"fastify","version":"5.12.0","via":"@devlab.group/agent-commerce"},{"name":"pino","version":"10.3.1","via":"@devlab.group/agent-commerce"},{"name":"zod","version":"3.25.76","via":"@devlab.group/agent-commerce"}]}' ;
-  {
-    return JSON.parse(injected);
-  }
+  const declared = {
+    ...package_default.peerDependencies,
+    ...package_default.dependencies
+  };
+  const pinned = PINS.flatMap(([name, via]) => {
+    const version = declared[name];
+    return version === void 0 ? [] : [{ name, version, via }];
+  });
+  return { cliVersion: PACKAGE_VERSION, pinned };
 }
 
 // src/cli/commands/doctor.ts
@@ -2905,19 +3067,20 @@ function deriveGatewayUrl(explicit, config) {
 function substitutePathParams(url) {
   let filled = url;
   for (const name of extractPathParameterNames(url)) {
-    filled = filled.split(`{${name}}`).join("demo-check");
+    filled = filled.replaceAll(`{${name}}`, "demo-check");
   }
   return filled;
 }
-function extractWellKnownX402(body) {
+function extractWellKnownX402(body, rail = "x402") {
   const payments = body?.["payments"];
   if (typeof payments !== "object" || payments === null) return void 0;
-  const x402 = payments["x402"];
-  if (typeof x402 !== "object" || x402 === null) return void 0;
-  const rec = x402;
+  const block = payments[rail];
+  if (typeof block !== "object" || block === null) return void 0;
+  const rec = block;
   if (rec["enabled"] === false) return "disabled";
   if (rec["enabled"] !== true) return void 0;
-  const { asset, network, payTo } = rec;
+  const { asset, network } = rec;
+  const payTo = rec[rail === "mpp" ? "recipient" : "payTo"];
   if (typeof asset !== "string" || typeof network !== "string" || typeof payTo !== "string") {
     return void 0;
   }
@@ -2926,7 +3089,7 @@ function extractWellKnownX402(body) {
 function sameAddress2(a, b) {
   return a.toLowerCase() === b.toLowerCase();
 }
-function findX402Mismatch(configured, live) {
+function findX402Mismatch(configured, live, payToField = "payTo") {
   const diffs = [];
   if (!sameAddress2(configured.asset, live.asset)) {
     diffs.push(
@@ -2940,11 +3103,26 @@ function findX402Mismatch(configured, live) {
   }
   if (!sameAddress2(configured.payTo, live.payTo)) {
     diffs.push(
-      `payTo: gateway is using ${live.payTo} but local config resolves to ${configured.payTo}`
+      `${payToField}: gateway is using ${live.payTo} but local config resolves to ${configured.payTo}`
     );
   }
   if (diffs.length === 0) return void 0;
-  return `${diffs.join("; ")} \u2014 the gateway may be running against an older deployment; restart it or re-run chain:deploy`;
+  return `${diffs.join("; ")}; the gateway may be running against an older deployment - restart it or re-run chain:deploy`;
+}
+function describeSettlement(network, facilitator) {
+  const profile = findNetworkProfile(network);
+  const mode = profile ? resolveDeploymentMode(profile, facilitator.mode) : void 0;
+  const where = profile === void 0 || mode === void 0 ? `unknown network ${network}` : mode === "local" ? `LOCAL dev chain (${network}, chain id shared with ${profile.displayName})` : `${describeDeploymentMode(mode)} on ${profile.displayName} (${network})`;
+  const via = facilitator.mode === "local" ? "local (in-process)" : `remote (auth=${facilitator.auth.type})`;
+  return { mode, where, via };
+}
+function mainnetSafetyCheck(name, payToField, facilitator) {
+  const unauthenticated = facilitator.mode === "remote" && facilitator.auth.type === "none";
+  return {
+    name,
+    status: unauthenticated ? "WARN" : "INFO",
+    detail: unauthenticated ? `${describeDeploymentMode("mainnet")}: no credential is sent to the remote facilitator (accepted via allowUnauthenticatedFacilitator); its anonymous-access limits apply. Config load also requires allowMainnet, HTTPS, a non-development ${payToField} and the canonical asset. Payments fail closed.` : `${describeDeploymentMode("mainnet")}. Enforced at config load: explicit allowMainnet opt-in, remote facilitator over HTTPS with a credential, non-development ${payToField}, and the canonical asset for this network. Payments fail closed.`
+  };
 }
 function describeIssuers(label, issuers) {
   const described = issuers.map(
@@ -2960,72 +3138,26 @@ function isWritableFile(path2) {
     return false;
   }
 }
-function ap2ReplayCheck(path2) {
-  const name = "AP2 replay store";
+function storeFileCheck(name, path2, risk, suffix = "") {
   if (path2 === ":memory:") {
     return {
       name,
       status: "WARN",
-      detail: "in-memory store - every spent mandate is forgotten on restart, so one could authorize a second purchase; use a file path in production"
+      detail: `in-memory store: ${risk.inMemory}; use a file path in production${suffix}`
     };
   }
   if (existsSync(path2)) {
-    return isWritableFile(path2) ? { name, status: "PASS", detail: `writable at "${path2}"` } : {
+    return isWritableFile(path2) ? { name, status: "PASS", detail: `writable at "${path2}"${suffix}` } : {
       name,
       status: "FAIL",
-      detail: `"${path2}" exists but is not writable by this user - no mandate could be recorded as spent`
+      detail: `"${path2}" exists but is not writable by this user, so ${risk.unwritable}${suffix}`
     };
   }
-  const directory = dirname(path2);
-  if (directory !== "" && directory !== "." && !existsSync(directory)) {
-    return {
-      name,
-      status: "WARN",
-      detail: `no store yet at "${path2}" and its directory does not exist - it is created when the gateway starts, provided that path is writable`
-    };
-  }
-  return {
-    name,
-    status: "WARN",
-    detail: `no store yet at "${path2}" - it is created the first time the gateway starts`
-  };
+  return { name, status: "WARN", detail: `${missingStoreDetail(path2)}${suffix}` };
 }
-function acpIdempotencyCheck(idempotency) {
-  const retention = `retention ${idempotency.retentionHours}h`;
-  if (idempotency.retentionHours < 24) {
-    return {
-      name: "ACP idempotency",
-      status: "FAIL",
-      detail: `${retention} is below the 24h ACP minimum \u2014 a replayed key could run a checkout twice`
-    };
-  }
-  if (idempotency.path === ":memory:") {
-    return {
-      name: "ACP idempotency",
-      status: "WARN",
-      detail: `in-memory store, ${retention} \u2014 replay protection is lost on every restart; use a file path in production`
-    };
-  }
-  const directory = dirname(idempotency.path);
-  if (existsSync(idempotency.path)) {
-    return isWritableFile(idempotency.path) ? { name: "ACP idempotency", status: "PASS", detail: `writable, ${retention}` } : {
-      name: "ACP idempotency",
-      status: "FAIL",
-      detail: `"${idempotency.path}" exists but is not writable by this user \u2014 the adapter cannot claim idempotency keys`
-    };
-  }
-  if (directory !== "" && directory !== "." && !existsSync(directory)) {
-    return {
-      name: "ACP idempotency",
-      status: "WARN",
-      detail: `no store yet at "${idempotency.path}" and its directory does not exist \u2014 it is created when the gateway starts, provided that path is writable`
-    };
-  }
-  return {
-    name: "ACP idempotency",
-    status: "WARN",
-    detail: `no store yet at "${idempotency.path}" \u2014 it is created the first time the gateway starts (${retention})`
-  };
+function missingStoreDetail(path2) {
+  const directory = dirname(path2);
+  return directory !== "." && !existsSync(directory) ? `no store at "${path2}" and its directory does not exist. Both are created when the gateway starts, provided the path is writable` : `no store at "${path2}" yet. It is created the first time the gateway starts`;
 }
 function acpMappingCheck(config, operations) {
   const byId = new Map(config.resources.map((resource) => [resource.id, resource]));
@@ -3069,11 +3201,11 @@ async function runDoctor(options, deps = {}) {
     checks.push({
       name: "Config",
       status: "PASS",
-      detail: `valid \u2014 ${config.resources.length} resource(s), merchant "${config.merchant.name}"${filledSuffix}`
+      detail: `valid: ${config.resources.length} resource(s), merchant "${config.merchant.name}"${filledSuffix}`
     });
   } catch (err) {
     const variable = isCommerceError(err) ? err.details?.["variable"] : void 0;
-    const hint = !manifestFound && typeof variable === "string" && MANIFEST_FILLABLE_ENV_VAR_NAMES.has(variable) ? ` \u2014 run "npm run chain:deploy" (writes ${LOCAL_CHAIN_MANIFEST_PATH}, read automatically for local X402_*/MERCHANT_WALLET placeholders)` : "";
+    const hint = !manifestFound && typeof variable === "string" && MANIFEST_FILLABLE_ENV_VAR_NAMES.has(variable) ? `. Run "npm run chain:deploy": it writes ${LOCAL_CHAIN_MANIFEST_PATH}, which fills local X402_*/MERCHANT_WALLET placeholders automatically` : "";
     checks.push({
       name: "Config",
       status: "FAIL",
@@ -3101,7 +3233,7 @@ async function runDoctor(options, deps = {}) {
     );
   }
   if (config === void 0) {
-    checks.push({ name: "Backend", status: "WARN", detail: "skipped \u2014 config invalid" });
+    checks.push({ name: "Backend", status: "WARN", detail: "skipped: config invalid" });
   } else if (config.resources.length === 0) {
     checks.push({ name: "Backend", status: "INFO", detail: "no resources configured" });
   } else {
@@ -3124,7 +3256,7 @@ async function runDoctor(options, deps = {}) {
     CHECK_TIMEOUT_MS
   ) : void 0;
   if (config === void 0) {
-    checks.push({ name: "Protocols", status: "WARN", detail: "skipped \u2014 config invalid" });
+    checks.push({ name: "Protocols", status: "WARN", detail: "skipped: config invalid" });
   } else if (wellKnown === void 0 || !wellKnown.ok) {
     checks.push({ name: "Protocols", status: "FAIL", detail: "well-known document unreachable" });
   } else {
@@ -3137,7 +3269,7 @@ async function runDoctor(options, deps = {}) {
     });
   }
   if (config === void 0) {
-    checks.push({ name: "A2A", status: "WARN", detail: "skipped \u2014 config invalid" });
+    checks.push({ name: "A2A", status: "WARN", detail: "skipped: config invalid" });
   } else if (!config.protocols.a2a.enabled) {
     checks.push({ name: "A2A", status: "INFO", detail: "disabled" });
   } else {
@@ -3153,7 +3285,7 @@ async function runDoctor(options, deps = {}) {
     });
   }
   if (config === void 0) {
-    checks.push({ name: "ACP", status: "WARN", detail: "skipped \u2014 config invalid" });
+    checks.push({ name: "ACP", status: "WARN", detail: "skipped: config invalid" });
   } else if (!config.protocols.acp.enabled) {
     checks.push({ name: "ACP", status: "INFO", detail: "disabled" });
   } else {
@@ -3168,7 +3300,17 @@ async function runDoctor(options, deps = {}) {
       status: "PASS",
       detail: `bearer token configured (${acp.auth.token.length} characters, not shown)`
     });
-    checks.push(acpIdempotencyCheck(acp.idempotency));
+    checks.push(
+      storeFileCheck(
+        "ACP idempotency",
+        acp.idempotency.path,
+        {
+          inMemory: "replay protection is lost on every restart",
+          unwritable: "the adapter cannot claim idempotency keys"
+        },
+        ` (retention ${acp.idempotency.retentionHours}h)`
+      )
+    );
     checks.push(acpMappingCheck(config, acp.checkout.operations));
     checks.push({
       name: "ACP unsupported",
@@ -3178,7 +3320,7 @@ async function runDoctor(options, deps = {}) {
   }
   const ap2 = config?.authorization?.ap2;
   if (config === void 0) {
-    checks.push({ name: "AP2", status: "WARN", detail: "skipped \u2014 config invalid" });
+    checks.push({ name: "AP2", status: "WARN", detail: "skipped: config invalid" });
   } else if (ap2 === void 0 || !ap2.enabled) {
     checks.push({ name: "AP2", status: "INFO", detail: "disabled" });
   } else {
@@ -3192,14 +3334,19 @@ async function runDoctor(options, deps = {}) {
       status: "PASS",
       detail: `${describeIssuers("mandate", ap2.trust.mandateIssuers)} \xB7 ${describeIssuers("checkout", ap2.trust.checkoutIssuers)}`
     });
-    checks.push(ap2ReplayCheck(ap2.replay.path));
+    checks.push(
+      storeFileCheck("AP2 replay store", ap2.replay.path, {
+        inMemory: "every spent mandate is forgotten on restart, so one could authorize a second purchase",
+        unwritable: "no mandate could be recorded as spent"
+      })
+    );
     const gated = config.resources.filter(
       (resource) => resource.authorization?.required.includes("ap2")
     );
     checks.push({
       name: "AP2 resources",
       status: gated.length > 0 ? "PASS" : "WARN",
-      detail: gated.length > 0 ? gated.map((resource) => resource.id).join(", ") : "AP2 is enabled but no resource requires it \u2014 every purchase settles without a mandate"
+      detail: gated.length > 0 ? gated.map((resource) => resource.id).join(", ") : "AP2 is enabled but no resource requires it, so every purchase settles without a mandate"
     });
     checks.push({
       name: "AP2 unsupported",
@@ -3211,23 +3358,20 @@ async function runDoctor(options, deps = {}) {
   if (x402 === void 0 || !x402.enabled) {
     checks.push({ name: "Payments", status: "INFO", detail: "x402 not configured" });
   } else {
-    const profile = findNetworkProfile(x402.network);
-    const mode = profile ? resolveDeploymentMode(profile, x402.facilitator.mode) : void 0;
-    const where = profile === void 0 || mode === void 0 ? `unknown network ${x402.network}` : mode === "local" ? `LOCAL dev chain (${x402.network}, chain id shared with ${profile.displayName})` : `${describeDeploymentMode(mode)} on ${profile.displayName} (${x402.network})`;
-    const facilitatorDetail = x402.facilitator.mode === "local" ? "local" : `remote (auth=${x402.facilitator.auth.type})`;
-    const summary = `x402 v2 (scheme=exact) enabled \u2014 ${where}, destination=${maskMiddle(x402.payTo)}, facilitator=${facilitatorDetail}`;
+    const { mode, where, via } = describeSettlement(x402.network, x402.facilitator);
+    const summary = `x402 v2 (scheme=exact) enabled - ${where}, destination=${maskMiddle(x402.payTo)}, facilitator=${via}`;
     const live = wellKnown?.ok ? extractWellKnownX402(wellKnown.body) : void 0;
     if (sameAddress2(x402.asset, PLACEHOLDER_ASSET_ADDRESS)) {
       checks.push({
         name: "Payments",
         status: "WARN",
-        detail: `${summary}, but the asset is still the init placeholder ${maskMiddle(PLACEHOLDER_ASSET_ADDRESS)} \u2014 no token contract exists there, so every paid call will fail. Set payments.x402.asset (\${X402_ASSET} is filled from .deploy/local.json by "npm run chain:deploy")`
+        detail: `${summary}, but the asset is still the init placeholder ${maskMiddle(PLACEHOLDER_ASSET_ADDRESS)}. No token contract exists there, so every paid call will fail. Set payments.x402.asset (\${X402_ASSET} is filled from .deploy/local.json, which "npm run chain:deploy" writes)`
       });
     } else if (live === "disabled") {
       checks.push({
         name: "Payments",
         status: "FAIL",
-        detail: `${summary}, but the gateway at ${gatewayUrl} reports x402 disabled \u2014 it is running a different configuration`
+        detail: `${summary}, but the gateway at ${gatewayUrl} reports x402 disabled, so it is running a different configuration`
       });
     } else if (live === void 0) {
       checks.push({
@@ -3242,35 +3386,53 @@ async function runDoctor(options, deps = {}) {
       );
     }
     if (mode === "mainnet") {
-      const unauthenticated = x402.facilitator.mode === "remote" && x402.facilitator.auth.type === "none";
+      checks.push(mainnetSafetyCheck("Mainnet safety", "payTo", x402.facilitator));
+    }
+  }
+  const mpp = config?.payments.mpp;
+  if (mpp === void 0 || !mpp.enabled) {
+    checks.push({ name: "Payments (MPP)", status: "INFO", detail: "MPP not configured" });
+  } else {
+    const { mode, where, via } = describeSettlement(mpp.network, mpp.facilitator);
+    const summary = `MPP ${MPP_PROFILE.intent}/${MPP_PROFILE.method}/${MPP_PROFILE.credentialType} enabled - ${where}, asset=${MPP_PROFILE.assetSymbol} ${maskMiddle(mpp.asset)}, recipient=${maskMiddle(mpp.recipient)}, facilitator=${via}, spec ${MPP_SPEC_DRAFTS.core}@${MPP_SPEC_COMMIT.slice(0, 7)}, mppx ${MPPX_VERSION}`;
+    const configured = { asset: mpp.asset, network: mpp.network, payTo: mpp.recipient };
+    const live = wellKnown?.ok ? extractWellKnownX402(wellKnown.body, "mpp") : void 0;
+    if (live === "disabled") {
       checks.push({
-        name: "Mainnet safety",
-        status: unauthenticated ? "WARN" : "INFO",
-        detail: unauthenticated ? `${describeDeploymentMode("mainnet")} \u2014 settling through a facilitator that takes no credential, accepted via allowUnauthenticatedFacilitator. It sees every payment authorisation you handle, with no account or terms behind it. Everything else is enforced at config load: explicit allowMainnet opt-in, HTTPS, non-development payTo, canonical asset. Payments are fail-closed.` : `${describeDeploymentMode("mainnet")} \u2014 enforced at config load: explicit allowMainnet opt-in, remote facilitator over HTTPS with a credential, non-development payTo, and the canonical asset for this network. Payments are fail-closed.`
+        name: "Payments (MPP)",
+        status: "FAIL",
+        detail: `Local config enables MPP, but ${gatewayUrl} reports it disabled`
       });
+    } else if (live === void 0) {
+      checks.push({
+        name: "Payments (MPP)",
+        status: "INFO",
+        detail: `${summary} (live MPP settlement config unavailable for comparison)`
+      });
+    } else {
+      const mismatch = findX402Mismatch(configured, live, "recipient");
+      checks.push(
+        mismatch === void 0 ? { name: "Payments (MPP)", status: "PASS", detail: summary } : { name: "Payments (MPP)", status: "FAIL", detail: mismatch }
+      );
+    }
+    if (mode === "mainnet") {
+      checks.push(mainnetSafetyCheck("Mainnet safety (MPP)", "recipient", mpp.facilitator));
     }
   }
-  checks.push({
-    name: "Payments (MPP)",
-    status: "INFO",
-    detail: "planned \u2014 not implemented in this release"
-  });
   if (config === void 0) {
-    checks.push({ name: "Storage", status: "WARN", detail: "skipped \u2014 config invalid" });
+    checks.push({ name: "Storage", status: "WARN", detail: "skipped: config invalid" });
   } else if (
-    // Diagnose without creating: createSqliteReceiptStore mkdir+creates the
-    // file, so calling it on a wrong path (a typo, or a container path read
-    // from the host) silently produces a fresh empty database and a false
-    // "healthy, receipts=0" PASS — a read-only command must not have this
-    // side effect, and it shadows the real store's real receipts entirely.
-    // `:memory:` never exists on disk by definition, so it always falls
-    // through to the real open/health/count branch below, same as today.
+    // Diagnose without creating: createSqliteReceiptStore creates the file,
+    // so opening a wrong path (a typo, or a container path read from the
+    // host) would leave an empty database and report it healthy, hiding the
+    // real one. `:memory:` never exists on disk, so it takes the open branch
+    // below.
     config.storage.receipts.path !== ":memory:" && !existsSync(config.storage.receipts.path)
   ) {
     checks.push({
       name: "Storage",
       status: "WARN",
-      detail: `no store exists yet at "${config.storage.receipts.path}" \u2014 it is created automatically the first time the gateway starts. If the gateway is already running, this path does not match the one it actually uses.`
+      detail: `${missingStoreDetail(config.storage.receipts.path)}. If the gateway is already running, this path does not match the one it uses.`
     });
   } else {
     let store;
@@ -3307,7 +3469,7 @@ async function runDoctor(options, deps = {}) {
       await store?.close();
     }
   }
-  if (wellKnown !== void 0 && wellKnown.ok) {
+  if (wellKnown?.ok) {
     checks.push({
       name: "Protocol versions",
       status: "PASS",
@@ -3318,7 +3480,7 @@ async function runDoctor(options, deps = {}) {
     checks.push({
       name: "Protocol versions",
       status: "INFO",
-      detail: `gateway unreachable \u2014 local pins: ${local.pinned.map((p) => `${p.name}@${p.version}`).join(", ")}`
+      detail: `gateway unreachable; local pins: ${local.pinned.map((p) => `${p.name}@${p.version}`).join(", ")}`
     });
   }
   const scored = checks.filter((c) => c.status !== "INFO");
@@ -3357,6 +3519,8 @@ init_core();
 // src/openapi/discover.ts
 init_errors();
 init_execution();
+init_is_record();
+init_constants4();
 
 // src/openapi/refs.ts
 init_errors();
@@ -3397,7 +3561,7 @@ function dereference(document, node, stack = []) {
 }
 function resolvePointer(document, ref) {
   const pointer = ref.slice(1);
-  if (pointer === "" || pointer === "/") return document;
+  if (pointer === "") return document;
   if (!pointer.startsWith("/")) {
     throw new CommerceError(
       "CONFIG_INVALID",
@@ -3407,12 +3571,22 @@ function resolvePointer(document, ref) {
   }
   let current = document;
   for (const rawSegment of pointer.slice(1).split("/")) {
-    const segment = decodeURIComponent(rawSegment).replaceAll("~1", "/").replaceAll("~0", "~");
+    let decoded;
+    try {
+      decoded = decodeURIComponent(rawSegment);
+    } catch {
+      throw new CommerceError(
+        "CONFIG_INVALID",
+        `OpenAPI reference "${ref}" contains a malformed percent-escape`,
+        { details: { ref } }
+      );
+    }
+    const segment = decoded.replaceAll("~1", "/").replaceAll("~0", "~");
     if (Array.isArray(current)) {
       const index = Number(segment);
       current = Number.isInteger(index) ? current[index] : void 0;
     } else if (typeof current === "object" && current !== null) {
-      current = current[segment];
+      current = Object.hasOwn(current, segment) ? current[segment] : void 0;
     } else {
       current = void 0;
     }
@@ -3436,8 +3610,7 @@ var SUPPORTED_METHODS = {
   delete: "DELETE"
 };
 var NON_OPERATION_KEYS = /* @__PURE__ */ new Set(["summary", "description", "servers", "parameters", "$ref"]);
-var ID_ALLOWED = /[^A-Za-z0-9_.-]+/g;
-var MAX_ID_LENGTH = 128;
+var ID_DISALLOWED = new RegExp(`[^${MCP_TOOL_NAME_CHARS}]+`, "g");
 function discoverOperations(loaded, options = {}) {
   const { document } = loaded;
   const diagnostics = [];
@@ -3463,16 +3636,24 @@ function discoverOperations(loaded, options = {}) {
     }
     const pathItem = dereference(document, rawPathItem).value;
     if (!isRecord(pathItem)) continue;
+    const unsupportedMethod = (name) => {
+      diagnostics.push({
+        severity: "warning",
+        code: "unsupported-method",
+        operation: `${name.toUpperCase()} ${path2}`,
+        message: `Skipped ${name.toUpperCase()} ${path2}: only GET, POST, PUT, PATCH and DELETE are supported`
+      });
+    };
     for (const [key, rawOperation] of Object.entries(pathItem)) {
       if (NON_OPERATION_KEYS.has(key) || key.startsWith("x-")) continue;
+      if (key === "additionalOperations") {
+        if (isRecord(rawOperation))
+          for (const name of Object.keys(rawOperation)) unsupportedMethod(name);
+        continue;
+      }
       const method = SUPPORTED_METHODS[key.toLowerCase()];
       if (method === void 0) {
-        diagnostics.push({
-          severity: "warning",
-          code: "unsupported-method",
-          operation: `${key.toUpperCase()} ${path2}`,
-          message: `Skipped ${key.toUpperCase()} ${path2}: only GET, POST, PUT, PATCH and DELETE are supported`
-        });
+        unsupportedMethod(key);
         continue;
       }
       const operation = dereference(document, rawOperation).value;
@@ -3522,8 +3703,8 @@ function discoverOperations(loaded, options = {}) {
         ...description !== void 0 ? { description } : {},
         parameters: [
           ...toArray(pathItem["parameters"]),
-          // Operation parameters last: Phase 4 lets the later one win, which is
-          // the OpenAPI override rule (same name + in).
+          // Operation parameters last: `mergeParameters` lets the later one win,
+          // the OpenAPI override rule (same `name` and `in`)
           ...toArray(operation["parameters"])
         ],
         ...operation["requestBody"] !== void 0 ? { requestBody: operation["requestBody"] } : {},
@@ -3535,12 +3716,12 @@ function discoverOperations(loaded, options = {}) {
   return { operations, diagnostics };
 }
 function toResourceId(operationId, method, path2) {
-  const fromOperationId = operationId === void 0 ? "" : normaliseId(operationId);
+  const fromOperationId = operationId === void 0 ? "" : normalizeId(operationId);
   if (fromOperationId !== "") return fromOperationId;
-  return normaliseId(`${method.toLowerCase()}_${path2}`);
+  return normalizeId(`${method.toLowerCase()}_${path2}`);
 }
-function normaliseId(value) {
-  return value.replace(ID_ALLOWED, "_").replace(/_+/g, "_").replace(/^[_.-]+|[_.-]+$/g, "").slice(0, MAX_ID_LENGTH);
+function normalizeId(value) {
+  return value.replace(ID_DISALLOWED, "_").replace(/_+/g, "_").replace(/^[_.-]+|[_.-]+$/g, "").slice(0, MCP_TOOL_NAME_MAX_LENGTH);
 }
 function selectServer(document, candidates, context, options, diagnostics) {
   if (options.baseUrl !== void 0) return options.baseUrl;
@@ -3552,12 +3733,13 @@ function selectServer(document, candidates, context, options, diagnostics) {
     if (typeof url !== "string" || url === "") continue;
     const substituted = substituteServerVariables(url, first["variables"], context, diagnostics);
     if (substituted === void 0) return void 0;
-    if (!isAbsoluteHttpUrl(substituted)) {
+    const issue = describeServerUrlIssue(substituted);
+    if (issue !== void 0) {
       diagnostics.push({
         severity: "error",
-        code: "relative-server-url",
+        code: issue.code,
         operation: context.resourceId,
-        message: `Skipped ${context.where}: server URL "${substituted}" is relative, so no backend host is known. Pass --base-url`
+        message: `Skipped ${context.where}: server URL "${substituted}" ${issue.reason}. Pass --base-url`
       });
       return void 0;
     }
@@ -3606,12 +3788,26 @@ function substituteServerVariables(url, variables, context, diagnostics) {
   return substituted;
 }
 function isAbsoluteHttpUrl(value) {
+  return describeServerUrlIssue(value) === void 0;
+}
+function describeServerUrlIssue(value) {
   try {
     const parsed = new URL(value);
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
-    return parsed.search === "" && parsed.hash === "";
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return { code: "invalid-server-url", reason: "must use http:// or https://" };
+    }
+    if (parsed.search !== "" || parsed.hash !== "") {
+      return {
+        code: "invalid-server-url",
+        reason: "must not contain a query string or fragment"
+      };
+    }
+    return void 0;
   } catch {
-    return false;
+    return {
+      code: "relative-server-url",
+      reason: "is relative or malformed, so no backend host is known"
+    };
   }
 }
 function assertAbsoluteHttpUrl(value, label) {
@@ -3623,18 +3819,20 @@ function assertAbsoluteHttpUrl(value, label) {
     );
   }
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function toArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+// src/openapi/draft.ts
+init_is_record();
+
 // src/openapi/request.ts
 init_execution();
+init_is_record();
 
 // src/openapi/schema.ts
 init_errors();
+init_is_record();
 var SUPPORTED_TYPES = /* @__PURE__ */ new Set([
   "object",
   "string",
@@ -3665,7 +3863,7 @@ function convertSchema(document, node, stack = []) {
   const dropped = /* @__PURE__ */ new Set();
   try {
     const schema = convertNode(document, node, stack, dropped);
-    return schema === void 0 ? { supported: false, reason: "schema could not be represented" } : { supported: true, schema, dropped: [...dropped] };
+    return { supported: true, schema, dropped: [...dropped] };
   } catch (error) {
     if (error instanceof UnsupportedSchema) return { supported: false, reason: error.message };
     if (isCommerceError(error)) return { supported: false, reason: error.message };
@@ -3678,11 +3876,8 @@ function convertNode(document, node, stack, dropped) {
   if (node === true) return {};
   if (node === false) throw new UnsupportedSchema("schema is `false`, which accepts no value");
   const resolved = dereference(document, node, stack);
-  const source = resolved.value;
-  if (typeof source !== "object" || source === null || Array.isArray(source)) {
-    throw new UnsupportedSchema("schema node is not an object");
-  }
-  const schemaNode = source;
+  const schemaNode = resolved.value;
+  if (!isRecord(schemaNode)) throw new UnsupportedSchema("schema node is not an object");
   if (Array.isArray(schemaNode["allOf"])) {
     return mergeAllOf(document, schemaNode, resolved.stack, dropped);
   }
@@ -3701,11 +3896,15 @@ function convertNode(document, node, stack, dropped) {
   }
   if (Array.isArray(schemaNode["enum"])) result["enum"] = [...schemaNode["enum"]];
   const properties = schemaNode["properties"];
-  if (isRecord2(properties)) {
+  if (isRecord(properties)) {
     const converted = {};
     for (const [name, sub] of Object.entries(properties)) {
-      const child = convertNode(document, sub, resolved.stack, dropped);
-      if (child !== void 0) converted[name] = child;
+      if (name === "__proto__") {
+        throw new UnsupportedSchema(
+          'schema declares a "__proto__" property, which cannot be imported'
+        );
+      }
+      converted[name] = convertNode(document, sub, resolved.stack, dropped);
     }
     result["properties"] = converted;
   }
@@ -3718,17 +3917,15 @@ function convertNode(document, node, stack, dropped) {
   if (typeof additional === "boolean") {
     result["additionalProperties"] = additional;
   } else if (additional !== void 0) {
-    const child = convertNode(document, additional, resolved.stack, dropped);
-    if (child !== void 0) result["additionalProperties"] = child;
-  } else if (isRecord2(properties)) {
+    result["additionalProperties"] = convertNode(document, additional, resolved.stack, dropped);
+  } else if (isRecord(properties)) {
     result["additionalProperties"] = false;
   }
   const items = schemaNode["items"];
   if (Array.isArray(items)) {
     dropped.add("items (tuple form)");
   } else if (items !== void 0) {
-    const child = convertNode(document, items, resolved.stack, dropped);
-    if (child !== void 0) result["items"] = child;
+    result["items"] = convertNode(document, items, resolved.stack, dropped);
   }
   for (const keyword of Object.keys(schemaNode)) {
     if (isCarriedKeyword(keyword) || ANNOTATION_KEYWORDS.has(keyword) || keyword.startsWith("x-")) {
@@ -3765,19 +3962,19 @@ function mergeAllOf(document, schema, stack, dropped) {
   const merged = { type: "object", properties: {}, required: [] };
   const properties = merged["properties"];
   const required = /* @__PURE__ */ new Set();
+  let open2 = false;
   const parts = [...branches, ...Object.keys(siblings).length > 0 ? [siblings] : []];
   for (const branch of parts) {
     const converted = convertNode(document, branch, stack, dropped);
-    if (converted === void 0) throw new UnsupportedSchema("allOf branch is empty");
     const types = typeList2(converted["type"]);
     if (types !== void 0 && !types.includes("object")) {
       throw new UnsupportedSchema("allOf mixes object and non-object schemas");
     }
     const branchProperties = converted["properties"];
-    if (isRecord2(branchProperties)) {
+    if (isRecord(branchProperties)) {
       for (const [name, sub] of Object.entries(branchProperties)) {
         const existing = properties[name];
-        if (existing !== void 0 && JSON.stringify(existing) !== JSON.stringify(sub)) {
+        if (existing !== void 0 && !isDeepStrictEqual(existing, sub)) {
           throw new UnsupportedSchema(
             `allOf branches declare property "${name}" differently, which cannot be merged`
           );
@@ -3793,18 +3990,24 @@ function mergeAllOf(document, schema, stack, dropped) {
         throw new UnsupportedSchema(`allOf branch uses "${keyword}", which cannot be merged`);
       }
     }
-    if (typeof converted["description"] === "string" && merged["description"] === void 0) {
-      merged["description"] = converted["description"];
+    for (const keyword of METADATA_KEYWORDS) {
+      if (Object.hasOwn(converted, keyword) && !Object.hasOwn(merged, keyword)) {
+        merged[keyword] = converted[keyword];
+      }
+    }
+    const additional = converted["additionalProperties"];
+    if (additional === true) open2 = true;
+    else if (isRecord(additional)) {
+      throw new UnsupportedSchema(
+        "allOf branch constrains additionalProperties, which cannot be merged"
+      );
     }
   }
   if (required.size > 0) merged["required"] = [...required];
   else delete merged["required"];
-  merged["additionalProperties"] = false;
+  merged["additionalProperties"] = open2;
   return merged;
 }
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // src/openapi/request.ts
 var PATH_GROUP = "path";
@@ -3858,16 +4061,10 @@ function mapRequest(loaded, candidate) {
       warn("unsupported-optional-parameter", `Omitted optional ${label}: unknown location`);
       continue;
     }
-    const unsupported = describeUnsupportedParameter(document, parameter, location);
-    if (unsupported !== void 0) {
-      if (required2) return skip("unsupported-required-parameter", `${label} ${unsupported}`);
-      warn("unsupported-optional-parameter", `Omitted optional ${label}: it ${unsupported}`);
-      continue;
-    }
-    const converted = convertSchema(document, parameter["schema"]);
+    const converted = convertParameter(document, parameter, location);
     if (!converted.supported) {
       if (required2) return skip("unsupported-required-parameter", `${label} ${converted.reason}`);
-      warn("unsupported-optional-parameter", `Omitted optional ${label}: ${converted.reason}`);
+      warn("unsupported-optional-parameter", `Omitted optional ${label}: it ${converted.reason}`);
       continue;
     }
     for (const keyword of converted.dropped) dropped.add(keyword);
@@ -3936,38 +4133,43 @@ function mapRequest(loaded, candidate) {
 function mergeParameters(document, parameters) {
   const byIdentity = /* @__PURE__ */ new Map();
   for (const raw of parameters) {
-    const resolved = dereference(document, raw).value;
-    if (typeof resolved !== "object" || resolved === null || Array.isArray(resolved)) continue;
-    const parameter = resolved;
+    const parameter = dereference(document, raw).value;
+    if (!isRecord(parameter)) continue;
     byIdentity.set(`${String(parameter["in"])}:${String(parameter["name"])}`, parameter);
   }
   return [...byIdentity.values()];
 }
-function describeUnsupportedParameter(document, parameter, location) {
+function convertParameter(document, parameter, location) {
+  const unsupported = (reason) => ({ supported: false, reason });
+  if (parameter["name"] === "__proto__") {
+    return unsupported("has a name that cannot be an input key");
+  }
   if (parameter["content"] !== void 0) {
-    return "uses the `content` form, whose media-type serialization the gateway does not perform";
+    return unsupported(
+      "uses the `content` form, whose media-type serialization the gateway does not perform"
+    );
   }
   const style = parameter["style"];
   if (location === "query" && typeof style === "string" && UNSUPPORTED_QUERY_STYLES.has(style)) {
-    return `uses style "${style}", which the gateway does not serialize`;
+    return unsupported(`uses style "${style}", which the gateway does not serialize`);
   }
   if (location === "path" && typeof style === "string" && style !== "simple") {
-    return `uses style "${style}"; the gateway substitutes plain values only`;
+    return unsupported(`uses style "${style}"; the gateway substitutes plain values only`);
   }
   const converted = convertSchema(document, parameter["schema"]);
-  if (!converted.supported) return converted.reason;
+  if (!converted.supported) return unsupported(`has an unusable schema: ${converted.reason}`);
   if (!isPrimitiveSchema(converted.schema)) {
-    return "is not a primitive; object and array parameters need serialization the gateway does not perform";
+    return unsupported(
+      "is not a primitive; object and array parameters need serialization the gateway does not perform"
+    );
   }
-  return void 0;
+  return converted;
 }
 function resolveBody(document, candidate) {
   if (candidate.requestBody === void 0) return { kind: "none" };
-  const resolved = dereference(document, candidate.requestBody).value;
-  if (typeof resolved !== "object" || resolved === null || Array.isArray(resolved)) {
-    return { kind: "none" };
-  }
-  const requestBody = resolved;
+  const resolvedBody = dereference(document, candidate.requestBody);
+  const requestBody = resolvedBody.value;
+  if (!isRecord(requestBody)) return { kind: "none" };
   const required = requestBody["required"] === true;
   if (candidate.method === "GET" || candidate.method === "DELETE") {
     return {
@@ -3977,7 +4179,7 @@ function resolveBody(document, candidate) {
     };
   }
   const content = requestBody["content"];
-  if (!isRecord3(content)) return { kind: "none" };
+  if (!isRecord(content)) return { kind: "none" };
   const mediaType = pickJsonMediaType(Object.keys(content));
   if (mediaType === void 0) {
     return {
@@ -3986,8 +4188,8 @@ function resolveBody(document, candidate) {
       reason: `no JSON request body content type (found: ${Object.keys(content).join(", ") || "none"}). Only application/json and application/*+json are supported - multipart and form data are never serialized as JSON`
     };
   }
-  const media = content[mediaType];
-  const schemaNode = isRecord3(media) ? media["schema"] : void 0;
+  const media = dereference(document, content[mediaType], resolvedBody.stack).value;
+  const schemaNode = isRecord(media) ? media["schema"] : void 0;
   if (schemaNode === void 0) {
     return {
       kind: "schema",
@@ -4008,10 +4210,10 @@ function resolveBody(document, candidate) {
   };
 }
 function pickJsonMediaType(keys) {
-  const normalised = keys.map((key) => ({ key, type: key.split(";")[0]?.trim().toLowerCase() }));
-  const exact = normalised.find((entry) => entry.type === "application/json");
+  const normalized = keys.map((key) => ({ key, type: key.split(";")[0]?.trim().toLowerCase() }));
+  const exact = normalized.find((entry) => entry.type === "application/json");
   if (exact !== void 0) return exact.key;
-  return [...normalised].sort((a, b) => (a.type ?? "").localeCompare(b.type ?? "")).find((entry) => entry.type?.startsWith("application/") && entry.type.endsWith("+json"))?.key;
+  return [...normalized].sort((a, b) => (a.type ?? "").localeCompare(b.type ?? "")).find((entry) => entry.type?.startsWith("application/") && entry.type.endsWith("+json"))?.key;
 }
 function closedObject(properties, required) {
   return {
@@ -4021,9 +4223,6 @@ function closedObject(properties, required) {
     additionalProperties: false
   };
 }
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // src/openapi/draft.ts
 function buildResourceDrafts(loaded, options = {}) {
@@ -4031,11 +4230,12 @@ function buildResourceDrafts(loaded, options = {}) {
     loaded,
     options.baseUrl !== void 0 ? { baseUrl: options.baseUrl } : {}
   );
-  const diagnostics = [...discovery.diagnostics];
+  const diagnostics = [];
   const drafts = [];
   const wanted = options.include?.operationIds;
   const wantedTags = options.include?.tags;
   const matched = /* @__PURE__ */ new Set();
+  const selected = /* @__PURE__ */ new Set();
   for (const candidate of discovery.operations) {
     if (wanted !== void 0 && !selects(wanted, candidate)) continue;
     if (wantedTags !== void 0 && !candidate.tags.some((tag) => wantedTags.includes(tag))) {
@@ -4044,6 +4244,7 @@ function buildResourceDrafts(loaded, options = {}) {
     if (wanted !== void 0) {
       for (const id of wanted) if (selects([id], candidate)) matched.add(id);
     }
+    selected.add(candidate.resourceId);
     const mapping = mapRequest(loaded, candidate);
     diagnostics.push(...mapping.diagnostics);
     if (!mapping.supported) continue;
@@ -4073,8 +4274,8 @@ function buildResourceDrafts(loaded, options = {}) {
     if (options.policy?.pricing === void 0 || options.policy.expose === void 0) {
       review.push(
         "REVIEW: pricing and exposure are not inferred from OpenAPI. Add e.g.",
-        '  pricing: { type: free }   # or { type: fixed, amount: "0.01", currency: USDC }',
-        "  expose: [http]           # http | mcp | a2a"
+        '  pricing: { type: free }   # or { type: fixed, amount: "0.01", currency: USDC } with payments: [x402]',
+        "  expose: [http]           # http | mcp | a2a | acp"
       );
     }
     drafts.push({
@@ -4094,12 +4295,9 @@ function buildResourceDrafts(loaded, options = {}) {
           ...mapping.contentType !== void 0 ? { headers: { "Content-Type": mapping.contentType } } : {},
           ...Object.keys(mapping.inputBindings).length > 0 ? { inputBindings: mapping.inputBindings } : {}
         },
-        // Policy is written only when the operator asked for it. An absent
-        // `pricing`/`expose` is what makes the draft fail config validation
-        // until a human has decided.
+        // Written only when the operator supplied it (see the file header)
         ...options.policy?.pricing !== void 0 ? { pricing: options.policy.pricing } : {},
-        ...options.policy?.expose !== void 0 ? { expose: [...options.policy.expose] } : {},
-        ...options.policy?.payments !== void 0 ? { payments: [...options.policy.payments] } : {}
+        ...options.policy?.expose !== void 0 ? { expose: [...options.policy.expose] } : {}
       },
       review
     });
@@ -4108,10 +4306,19 @@ function buildResourceDrafts(loaded, options = {}) {
     version: loaded.version,
     sourcePath: loaded.sourcePath,
     drafts,
-    diagnostics,
+    diagnostics: [
+      ...selectDiscoveryDiagnostics(discovery.diagnostics, options.include, selected),
+      ...diagnostics
+    ],
     unmatchedOperationIds: (wanted ?? []).filter((id) => !matched.has(id))
   };
 }
+function selectDiscoveryDiagnostics(found, include, selected) {
+  if (include?.operationIds === void 0 && include?.tags === void 0) return found;
+  return found.filter(
+    ({ operation }) => operation === void 0 || selected.has(operation) || include.operationIds?.includes(operation) === true
+  );
+}
 function selects(ids, candidate) {
   return ids.includes(candidate.resourceId) || candidate.operationId !== void 0 && ids.includes(candidate.operationId);
 }
@@ -4122,22 +4329,31 @@ function declaresSecurity(candidate) {
 }
 function selectOutputSchema(document, candidate, diagnostics, dropped) {
   const responses = candidate.responses;
-  if (!isRecord4(responses)) return void 0;
+  if (!isRecord(responses)) return void 0;
   const successes = Object.keys(responses).filter((status) => /^2\d\d$/.test(status)).sort((a, b) => rank(a) - rank(b));
   if (successes.length === 0) return void 0;
-  const withBody = successes.filter((status) => {
-    const response2 = responses[status];
-    const content2 = isRecord4(response2) ? response2["content"] : void 0;
-    return isRecord4(content2) && pickJsonMediaType(Object.keys(content2)) !== void 0;
+  const withBody = successes.flatMap((status) => {
+    const response = dereference(document, responses[status]);
+    if (!isRecord(response.value)) return [];
+    const content = response.value["content"];
+    if (!isRecord(content)) return [];
+    const mediaType = pickJsonMediaType(Object.keys(content));
+    if (mediaType === void 0) return [];
+    const media = dereference(document, content[mediaType], response.stack).value;
+    return isRecord(media) ? [{ status, media }] : [];
   });
   const chosen = withBody[0];
   if (chosen === void 0) return void 0;
-  const response = responses[chosen];
-  const content = response["content"];
-  const mediaType = pickJsonMediaType(Object.keys(content));
-  const media = content[mediaType];
-  const schemaNode = isRecord4(media) ? media["schema"] : void 0;
-  if (schemaNode === void 0) return void 0;
+  const schemaNode = chosen.media["schema"];
+  if (schemaNode === void 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "missing-output-schema",
+      operation: candidate.resourceId,
+      message: `${candidate.resourceId}: response ${chosen.status} has JSON content without a schema; omitted the output schema`
+    });
+    return void 0;
+  }
   const converted = convertSchema(document, schemaNode);
   if (!converted.supported) {
     diagnostics.push({
@@ -4154,7 +4370,7 @@ function selectOutputSchema(document, candidate, diagnostics, dropped) {
       severity: "warning",
       code: "multiple-success-responses",
       operation: candidate.resourceId,
-      message: `${candidate.resourceId}: responses ${withBody.join(", ")} all carry a JSON body; used ${chosen}`
+      message: `${candidate.resourceId}: responses ${withBody.map(({ status }) => status).join(", ")} all carry a JSON body; used ${chosen.status}`
     });
   }
   return converted.schema;
@@ -4169,7 +4385,8 @@ function renderResourcesYaml(result) {
   const doc = new Document({ resources });
   doc.commentBefore = [
     " Generated by agent-commerce import openapi. Review before use.",
-    ` Source: ${basename(result.sourcePath)} (OpenAPI ${result.version})`,
+    // win32.basename splits on both / and \
+    ` Source: ${win32.basename(result.sourcePath)} (OpenAPI ${result.version})`,
     " Merge the resources below into config.yaml once pricing, exposure and",
     " any backend authentication have been decided."
   ].join("\n");
@@ -4182,12 +4399,6 @@ function renderResourcesYaml(result) {
   });
   return doc.toString({ lineWidth: 0 });
 }
-function basename(path2) {
-  return path2.split(/[\\/]/).pop() ?? path2;
-}
-function isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // src/openapi/load.ts
 init_errors();
@@ -4200,6 +4411,31 @@ function invalid2(message, details, cause) {
     ...cause !== void 0 ? { cause } : {}
   });
 }
+async function readCapped(sourcePath, details) {
+  const buffer = Buffer.alloc(MAX_SOURCE_BYTES + 1);
+  let length = 0;
+  try {
+    const handle = await open(sourcePath, "r");
+    try {
+      while (length < buffer.length) {
+        const { bytesRead } = await handle.read(buffer, length, buffer.length - length, null);
+        if (bytesRead === 0) break;
+        length += bytesRead;
+      }
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    throw invalid2(`OpenAPI document "${sourcePath}" could not be read`, details, error);
+  }
+  if (length > MAX_SOURCE_BYTES) {
+    throw invalid2(`OpenAPI document "${sourcePath}" is over the ${MAX_SOURCE_BYTES}-byte limit`, {
+      ...details,
+      maxBytes: MAX_SOURCE_BYTES
+    });
+  }
+  return buffer.toString("utf8", 0, length);
+}
 async function loadOpenApiDocument(sourcePath) {
   const details = { sourcePath };
   let stats;
@@ -4224,7 +4460,7 @@ async function loadOpenApiDocument(sourcePath) {
       details
     );
   }
-  const source = await readFile(sourcePath, "utf8");
+  const source = await readCapped(sourcePath, details);
   if (source.trim() === "") {
     throw invalid2(`OpenAPI document "${sourcePath}" is empty`, details);
   }
@@ -4243,7 +4479,7 @@ async function loadOpenApiDocument(sourcePath) {
   }
   const document = parsed;
   const version = readVersion(document, sourcePath);
-  rejectExternalReferences(document, sourcePath);
+  rejectUnsupportedReferences(document, sourcePath);
   const result = await validate(document);
   if (!result.valid) {
     const first = result.errors?.[0];
@@ -4275,7 +4511,7 @@ function readVersion(document, sourcePath) {
   }
   return featureVersion;
 }
-function rejectExternalReferences(document, sourcePath) {
+function rejectUnsupportedReferences(document, sourcePath) {
   const seen = /* @__PURE__ */ new WeakSet();
   const queue = [document];
   while (queue.length > 0) {
@@ -4288,31 +4524,45 @@ function rejectExternalReferences(document, sourcePath) {
       continue;
     }
     for (const [key, value] of Object.entries(node)) {
-      if (key === "$ref" && typeof value === "string" && !value.startsWith("#")) {
-        throw invalid2(
-          `OpenAPI document "${sourcePath}" contains an external reference "${value}". Only internal references (#/...) are supported; the importer performs no network or filesystem lookups`,
-          { sourcePath, ref: value }
-        );
+      if (key === "$ref" && typeof value === "string") {
+        if (!value.startsWith("#")) {
+          throw invalid2(
+            `OpenAPI document "${sourcePath}" contains an external reference "${value}". Only internal references (#/...) are supported; the importer performs no network or filesystem lookups`,
+            { sourcePath, ref: value }
+          );
+        }
+        if (!isPercentDecodable(value)) {
+          throw invalid2(
+            `OpenAPI document "${sourcePath}" contains a reference "${value}" with a malformed percent-escape`,
+            { sourcePath, ref: value }
+          );
+        }
       }
       queue.push(value);
     }
   }
 }
+function isPercentDecodable(value) {
+  try {
+    decodeURIComponent(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/cli/commands/import-openapi.ts
 function defaultOutputPath(source) {
-  const name = basename$1(source);
+  const name = basename(source);
   const stem = name.slice(0, name.length - extname(name).length) || name;
   return `${stem}.agent-commerce.yaml`;
 }
 async function runImportOpenApi(options, io, deps = {}) {
   const fileExists = deps.fileExists ?? existsSync;
   const outputPath = options.output ?? defaultOutputPath(options.source);
-  let policy;
-  try {
-    policy = buildPolicy(options);
-  } catch (error) {
-    io.stderr(`FAIL  ${error instanceof Error ? error.message : String(error)}`);
+  const policy = buildPolicy(options);
+  if (typeof policy === "string") {
+    io.stderr(`FAIL  ${policy}`);
     return 1;
   }
   if (fileExists(outputPath) && options.force !== true) {
@@ -4393,13 +4643,11 @@ function buildPolicy(options) {
   if (options.expose !== void 0) {
     const requested = options.expose.split(",").map((name) => name.trim()).filter((name) => name !== "");
     if (requested.length === 0) {
-      throw new Error(`--expose needs at least one protocol (${PROTOCOL_NAMES.join(", ")})`);
+      return `--expose needs at least one protocol (${PROTOCOL_NAMES.join(", ")})`;
     }
     for (const name of requested) {
       if (!PROTOCOL_NAMES.includes(name)) {
-        throw new Error(
-          `--expose "${name}" is not a supported protocol. Supported: ${PROTOCOL_NAMES.join(", ")}`
-        );
+        return `--expose "${name}" is not a supported protocol. Supported: ${PROTOCOL_NAMES.join(", ")}`;
       }
     }
     policy.expose = requested;
@@ -4473,14 +4721,6 @@ function formatConfigError(err, manifestFound = false) {
     }
     return lines.join("\n");
   }
-  if (err instanceof ZodError) {
-    const lines = ["FAIL  Configuration schema errors:"];
-    for (const issue of err.issues) {
-      const path2 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-      lines.push(`      - ${path2}: ${issue.message}`);
-    }
-    return lines.join("\n");
-  }
   if (err instanceof Error) {
     return `FAIL  ${err.message}`;
   }
@@ -4504,7 +4744,11 @@ async function runValidate(options, io, deps = {}) {
     io.stdout(
       `      protocols: http=${config.protocols.http.enabled ? "on" : "off"} mcp=${config.protocols.mcp.enabled ? "on" : "off"} a2a=${config.protocols.a2a.enabled ? "on" : "off"} acp=${config.protocols.acp.enabled ? "on" : "off"}`
     );
-    io.stdout(`      payments: x402=${config.payments.x402?.enabled === true ? "on" : "off"}`);
+    const onOff = (enabled) => enabled === true ? "on" : "off";
+    io.stdout(
+      `      payments: x402=${onOff(config.payments.x402?.enabled)} mpp=${onOff(config.payments.mpp?.enabled)}`
+    );
+    io.stdout(`      authorization: ap2=${onOff(config.authorization?.ap2.enabled)}`);
     return 0;
   } catch (err) {
     io.stderr(formatConfigError(err, manifestFound));
@@ -4518,8 +4762,7 @@ async function collectAnswersInteractive() {
   const backendBaseUrl = await clack.text({
     message: "Backend base URL (your existing merchant API)",
     initialValue: "http://localhost:3000",
-    // shape-checked here, where the user can retype it,
-    // rather than surfacing as a config error after the fact.
+    // Checked here, where the user can retype it, rather than as a config error later
     validate: (value) => {
       const trimmed = (value ?? "").trim();
       if (trimmed.length === 0) return "Required";
@@ -4556,12 +4799,8 @@ async function collectAnswersInteractive() {
       { value: "mcp", label: "MCP" }
     ],
     initialValues: ["http", "mcp"],
-    // `required: false` permits an empty selection, which renders
-    // `expose: []` on every resource and fails the schema's min(1). clack's
-    // multiselect has no `validate` hook, so this is caught by the in-memory
-    // validation in `runInit` — which now reports the real schema error and
-    // writes nothing, instead of leaving an invalid file behind.
-    required: false
+    // Every resource needs at least one protocol in `expose`
+    required: true
   });
   if (clack.isCancel(protocols)) {
     clack.cancel("Aborted.");
@@ -4575,7 +4814,7 @@ async function collectAnswersInteractive() {
   let merchantPayTo = defaultInitAnswers().merchantPayTo;
   if (x402Enabled) {
     const answer = await clack.text({
-      message: "Merchant settlement destination address (merchant-controlled \u2014 never a gateway-owned wallet)",
+      message: "Merchant settlement address (enter an address you control)",
       initialValue: merchantPayTo,
       validate: (value) => {
         const trimmed = (value ?? "").trim();
@@ -4618,20 +4857,16 @@ async function runInit(options, io, deps = {}) {
     return 1;
   }
   const yamlContent = renderInitConfigYaml(answers);
-  const resolvedPath = resolve(outputPath);
-  const dir = dirname(resolvedPath);
-  if (dir !== "" && !existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
+  mkdirSync(dirname(resolve(outputPath)), { recursive: true });
   await writeFileImpl(outputPath, yamlContent);
   io.stdout(`PASS  Wrote ${outputPath}`);
-  io.stdout(`PASS  ${outputPath} is valid \u2014 ${config.resources.length} resource(s)`);
+  io.stdout(`PASS  ${outputPath} is valid: ${config.resources.length} resource(s)`);
   try {
     await loadConfig2({ path: outputPath });
   } catch (err) {
     io.stderr(formatConfigError(err));
     io.stderr(
-      `FAIL  ${outputPath} was written but does not parse, although the same answers validated in memory \u2014 this is a bug in the config renderer, please report it.`
+      `FAIL  ${outputPath} was written but does not parse, although the same answers validated in memory. This is a bug in the config renderer; please report it.`
     );
     return 1;
   }
@@ -4650,8 +4885,9 @@ function runVersion(io, deps = {}) {
   if (report.pinned.length > 0) {
     io.stdout("");
     io.stdout("Pinned protocol / SDK versions:");
+    const width = Math.max(...report.pinned.map((pin) => pin.name.length));
     for (const pin of report.pinned) {
-      io.stdout(`  ${pin.name.padEnd(24)} ${pin.version.padEnd(12)} (via ${pin.via})`);
+      io.stdout(`  ${pin.name.padEnd(width)}  ${pin.version.padEnd(12)} (via ${pin.via})`);
     }
   }
   return 0;
@@ -4702,7 +4938,10 @@ function buildProgram(io = processIo) {
     process.exitCode = code;
   });
   const importCommand = program.command("import").description("Generate Agent Commerce resource drafts from an API description.");
-  importCommand.command("openapi").description("Convert a local OpenAPI 3.0/3.1/3.2 document into resource drafts.").argument("<source>", "path to a local .yaml, .yml or .json OpenAPI document").option("--output <path>", "output path (default: <source>.agent-commerce.yaml)").option("--force", "overwrite an existing output file", false).option("--base-url <url>", "backend base URL, overriding the document servers").option(
+  importCommand.command("openapi").description("Convert a local OpenAPI 3.0/3.1/3.2 document into resource drafts.").argument("<source>", "path to a local .yaml, .yml or .json OpenAPI document").option(
+    "--output <path>",
+    "output path (default: <source name without extension>.agent-commerce.yaml in the current directory)"
+  ).option("--force", "overwrite an existing output file", false).option("--base-url <url>", "backend base URL, overriding the document servers").option(
     "--operation <operationId>",
     "import only this operation (repeatable)",
     collect,
@@ -4727,7 +4966,7 @@ function buildProgram(io = processIo) {
     }
   );
   program.command("demo").description(
-    "Run the documented docker compose + demo agent quickstart, verifying health between steps."
+    "Start the local stack with docker compose (waiting for healthy services), then run the demo agent. Run it from a repo clone."
   ).action(async () => {
     process.exitCode = await runDemo(io);
   });