portage-ucp 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9198c70ed7abc380268adc344d7496c049a3c78c0ed28b16944e3b27d9d01ba
-  data.tar.gz: c076c1b4e544825d0db160bf2453fed3e256b2024c7aafb8f431227ec22364ef
+  metadata.gz: add1fc4dcd1b12c3dea3ade248972c2fd2616233b074230838daccce41c9033d
+  data.tar.gz: e75364c190c83ee0b9f6bc43f2aca2ef5067d8a4baf3ad5c1b6534fd1096abd7
 SHA512:
-  metadata.gz: 80aac639014575e4416c3e477f451bf9cb25b3cd69ab8a3cda512bd19243d51a95b54c5086b738fc9140be4e0318cb17b81a30767f2ba6b18546b6cd22e9a33b
-  data.tar.gz: dc0f578ee8d379f9f12c4605dcaf37757d5518f2764087186669a4809773b5bd869192328a0027ef61fd36f5a4dbc629697841e57f9065c96a9a5d5d7796c11a
+  metadata.gz: 72c18740172d1aeec163bbc7754d2190f59a92c8fa347256e344ff247ff30b8d4a046ad7f368c7b458b24be9e012748e045f7b4d059b9cef6df509c2aab200da
+  data.tar.gz: 2fd42daa906727619d78a276926461c886ec9b20ce81e9bc5c99fe5b0e229172696edef94df5e9ef108ebc6cedcfb1435b62c6590ae96e2ccaaeb218b8778713

data/CHANGELOG.md

@@ -4,7 +4,33 @@ All notable changes to this project are documented here. Format loosely follows
 [Keep a Changelog](https://keepachangelog.com/en/1.0.0/); this project is
 pre-1.0, so APIs may still shift between minor versions.
 
-## [0.1.0] - Unreleased
+## [0.2.0] - 2026-08-21
+
+- `Portage::Ucp::OutOfStockError` — the contract for `#complete_checkout`
+  (design-log §16 "Stock/availability going stale") now documents that
+  adapters should raise it when the platform rejects completion over a
+  no-longer-available line item, instead of re-checking with a separate call
+  agents could forget to make.
+- `Adapter#cancel_order`, `#request_return`, `#refund_order` — a gem-side
+  extension of `dev.ucp.shopping.order` (design-log §16 "Order changes"),
+  since the real UCP spec's order lifecycle is get-only. Each returns the
+  updated `Order`, with the change recorded as an appended
+  `Portage::Ucp::Adjustment`.
+- `Capability#predicate` — a minimal escape hatch for extensions that add
+  fields rather than actions (`dev.ucp.shopping.discount`,
+  `dev.ucp.shopping.fulfillment`): a capability can name an adapter method
+  instead of an action set, and `#advertised_for?` asks it directly.
+  `create_cart`/`update_cart`/`create_checkout`/`update_checkout` gain an
+  optional `discount_codes:` param defaulting to `nil` (not `[]`), so "not
+  mentioned" and "clear the codes" stay distinguishable.
+- `dev.ucp.shopping.fulfillment` — the vendored extension for picking a
+  shipping method/rate or pickup location during checkout. New value objects
+  `PostalAddress`, `ShippingDestination`, `RetailLocation`,
+  `FulfillmentOption`, `FulfillmentGroup`, `FulfillmentMethod`, and the
+  `CheckoutFulfillment` container (named apart from `Fulfillment`, which
+  Order's post-purchase container already owns — see design-log).
+
+## [0.1.0] - 2026-08-14
 
 - Initial pre-release. Protocol-only core: `Adapter` contract, capability
   registry, manifest builder, MCP server wrapper, offline `SchemaValidator`,

data/lib/portage/ucp/adapter.rb

@@ -17,24 +17,53 @@ module Portage
       # builds the response's Item/Total/LineItem itself.
       # @return [Portage::Ucp::Cart]
       def get_cart(cart_id:) = not_implemented
+      # `discount_codes:` is the dev.ucp.shopping.discount extension — nil
+      # (the default) means the request didn't touch discounts at all; an
+      # adapter that doesn't override #discount_codes_supported? never sees
+      # anything but nil here (see below). Full-replacement like line_items:
+      # once codes are involved, [] clears them, same as UCP's own
+      # discounts_object semantics.
       # @return [Portage::Ucp::Cart]
-      def create_cart(line_items:, idempotency_key:) = not_implemented
+      def create_cart(line_items:, idempotency_key:, discount_codes: nil) = not_implemented
       # @return [Portage::Ucp::Cart]
-      def update_cart(cart_id:, line_items:, idempotency_key:) = not_implemented
+      def update_cart(cart_id:, line_items:, idempotency_key:, discount_codes: nil) = not_implemented
       # @return [Portage::Ucp::Cart]
       def cancel_cart(cart_id:, idempotency_key:) = not_implemented
 
       # --- Checkout (dev.ucp.shopping.checkout) ---
+      # `discount_codes:` carries the same dev.ucp.shopping.discount
+      # semantics as create_cart/update_cart above.
+      # `fulfillment:` is the dev.ucp.shopping.fulfillment extension — nil
+      # (the default) means the request didn't touch fulfillment at all; an
+      # adapter that doesn't override #fulfillment_supported? never sees
+      # anything but nil here (see below). On create it carries the agent's
+      # desired methods (type + line_item_ids per shipping/pickup group —
+      # `Portage::Ucp::FulfillmentMethod#id`/`#destinations`/`#groups` are
+      # omitted since the merchant generates those); on update it carries the
+      # agent's `selected_destination_id`/`selected_option_id` choices against
+      # the methods/groups the merchant already returned.
       # @return [Portage::Ucp::Checkout]
-      def create_checkout(line_items:, idempotency_key:) = not_implemented
+      def create_checkout(line_items:, idempotency_key:, discount_codes: nil, fulfillment: nil) = not_implemented
       # @return [Portage::Ucp::Checkout]
       def get_checkout(checkout_id:) = not_implemented
+
       # Full-replacement, same as update_cart — line_items is required on
       # checkout update per the real spec.
       # @return [Portage::Ucp::Checkout]
-      def update_checkout(checkout_id:, line_items:, idempotency_key:) = not_implemented
+      def update_checkout(checkout_id:, line_items:, idempotency_key:, discount_codes: nil, fulfillment: nil)
+        not_implemented
+      end
+
       # @param payment_token [String] single-use token from a UCP payment handler / AP2
       #   exchange — NEVER a raw PAN.
+      # Re-checks stock at the point of committing money, since search_catalog/
+      # get_product (dev.ucp.shopping.catalog) don't promise live inventory and
+      # nothing else re-checks between browsing and buying. An adapter whose
+      # platform rejects completion because a line item is out of stock or
+      # otherwise unavailable should raise Portage::Ucp::OutOfStockError rather
+      # than a generic/platform error, so callers can distinguish a stale-stock
+      # failure from e.g. a declined payment.
+      # @raise [Portage::Ucp::OutOfStockError] if a line item is no longer available
       # @return [Portage::Ucp::Checkout]
       def complete_checkout(checkout_id:, payment_token:, idempotency_key:) = not_implemented
       # @return [Portage::Ucp::Checkout]
@@ -43,6 +72,37 @@ module Portage
       # --- Order (dev.ucp.shopping.order) ---
       # @return [Portage::Ucp::Order, nil]
       def get_order(order_id:) = not_implemented
+      # Cancels a placed order. `reason` is an optional human-readable note,
+      # not a closed enum — the platform-specific enum mapping (if any) is an
+      # adapter concern.
+      # @return [Portage::Ucp::Order]
+      def cancel_order(order_id:, idempotency_key:, reason: nil) = not_implemented
+      # Requests a return for one or more order line items. `line_items` is an
+      # array of request-shaped hashes (`{id:, quantity:}`, unsigned) — same
+      # request/response asymmetry as `create_cart`'s `line_items:`. A return
+      # is a request the merchant still has to process; it shows up as a
+      # `pending` `Portage::Ucp::Adjustment` until they do.
+      # @return [Portage::Ucp::Order]
+      def request_return(order_id:, line_items:, idempotency_key:, reason: nil) = not_implemented
+      # Refunds one or more order line items.
+      # @return [Portage::Ucp::Order]
+      def refund_order(order_id:, line_items:, idempotency_key:, reason: nil) = not_implemented
+
+      # --- Discount (dev.ucp.shopping.discount) ---
+      # Extends Cart/Checkout with the `discount_codes:` param above rather
+      # than adding actions of its own — Capability::DISCOUNT advertises off
+      # this predicate instead of an overridden action method, since there's
+      # no dedicated method for #advertised_for? to detect an override on.
+      # @return [Boolean]
+      def discount_codes_supported? = false
+
+      # --- Fulfillment (dev.ucp.shopping.fulfillment) ---
+      # Extends Checkout with the `fulfillment:` param above rather than
+      # adding actions of its own — Capability::FULFILLMENT advertises off
+      # this predicate instead of an overridden action method, same rationale
+      # as #discount_codes_supported? above.
+      # @return [Boolean]
+      def fulfillment_supported? = false
 
       # --- Identity Linking (dev.ucp.shopping.identity, OAuth 2.0) ---
       # @return [Portage::Ucp::Identity] linked profile for an exchanged OAuth token

data/lib/portage/ucp/capabilities/discount.rb

@@ -0,0 +1,16 @@
+module Portage
+  module Ucp
+    module Capabilities
+      # schemas/shopping/discount.json — extends Cart/Checkout with a
+      # `discounts` field rather than adding actions of its own, so `actions`
+      # is empty and advertisement runs off Adapter#discount_codes_supported?
+      # instead (see Capability#advertised_for?).
+      DISCOUNT = Portage::Ucp::Capability.new(
+        name: "dev.ucp.shopping.discount",
+        version: "1",
+        actions: {},
+        predicate: :discount_codes_supported?
+      )
+    end
+  end
+end

data/lib/portage/ucp/capabilities/fulfillment.rb

@@ -0,0 +1,16 @@
+module Portage
+  module Ucp
+    module Capabilities
+      # schemas/shopping/fulfillment.json — extends Checkout with a
+      # `fulfillment` field (shipping/pickup methods, groups, destinations)
+      # rather than adding actions of its own, same predicate-based
+      # advertisement as DISCOUNT above.
+      FULFILLMENT = Portage::Ucp::Capability.new(
+        name: "dev.ucp.shopping.fulfillment",
+        version: "1",
+        actions: {},
+        predicate: :fulfillment_supported?
+      )
+    end
+  end
+end

data/lib/portage/ucp/capabilities/identity_linking.rb

@@ -7,7 +7,7 @@ module Portage
         actions: { "link_identity" => :link_identity }
       )
 
-      ALL = [CATALOG, CART, CHECKOUT, ORDER, IDENTITY_LINKING].freeze
+      ALL = [CATALOG, CART, CHECKOUT, ORDER, IDENTITY_LINKING, DISCOUNT, FULFILLMENT].freeze
     end
   end
 end

data/lib/portage/ucp/capabilities/order.rb

@@ -4,7 +4,12 @@ module Portage
       ORDER = Portage::Ucp::Capability.new(
         name: "dev.ucp.shopping.order",
         version: "1",
-        actions: { "get_order" => :get_order }
+        actions: {
+          "get_order" => :get_order,
+          "cancel_order" => :cancel_order,
+          "request_return" => :request_return,
+          "refund_order" => :refund_order
+        }
       )
     end
   end

data/lib/portage/ucp/capability.rb

@@ -5,15 +5,25 @@ module Portage
     class Capability
       attr_reader :name, :version, :actions
 
-      def initialize(name:, version:, actions:)
+      # `predicate:` is for extension capabilities like
+      # dev.ucp.shopping.discount and dev.ucp.shopping.fulfillment that add a
+      # param to an existing action rather than an action of their own —
+      # there's no dedicated method whose override signals support, so the
+      # adapter exposes a boolean method instead and the capability asks it
+      # directly rather than inspecting `actions`.
+      def initialize(name:, version:, actions:, predicate: nil)
         @name = name
         @version = version
         @actions = actions
+        @predicate = predicate
       end
 
-      # Advertised only if at least one backing Adapter method is overridden —
+      # Advertised if the predicate says so, or (for ordinary action-based
+      # capabilities) if at least one backing Adapter method is overridden —
       # see Portage::Ucp::Adapter for why (contract can grow without breaking adapters).
       def advertised_for?(adapter)
+        return adapter.public_send(@predicate) if @predicate
+
         actions.values.any? { |method_name| overridden?(adapter, method_name) }
       end
 

data/lib/portage/ucp/errors.rb

@@ -8,5 +8,13 @@ module Portage
     class AuthenticationError < Error; end
     class RawPanRejectedError < Error; end
     class RateLimitExceededError < Error; end
+    # Raised by #complete_checkout when the platform rejects completion
+    # because a line item is out of stock or otherwise unavailable —
+    # design-log §16 "Stock/availability going stale": the gem re-checks by
+    # surfacing the platform's own rejection rather than adding a separate
+    # check_availability call agents could forget to make. Maps to UCP's
+    # standardized "out_of_stock"/"item_unavailable" error codes
+    # (schemas/shopping/types/error_code.json).
+    class OutOfStockError < Error; end
   end
 end

data/lib/portage/ucp/value_objects.rb

@@ -49,13 +49,183 @@ module Portage
       end
     end
 
+    # schemas/shopping/discount.json#/$defs/applied_discount — requires title/
+    # amount. `code` is omitted for automatic discounts; `allocations` (the
+    # per-target breakdown) is left empty rather than guessed at by adapters
+    # that can't source it from their platform.
+    # `allocation_method` maps to the wire key "method" — bare `:method` as a
+    # Data.define member would shadow Kernel#method.
+    AppliedDiscount = Data.define(:title, :amount, :code, :automatic, :allocation_method, :priority, :provisional,
+                                  :eligibility, :allocations) do
+      def initialize(title:, amount:, code: nil, automatic: false, allocation_method: nil, priority: nil,
+                     provisional: false, eligibility: nil, allocations: [])
+        super
+      end
+
+      def to_wire_h
+        h = { "title" => title, "amount" => amount }
+        { code: "code", automatic: "automatic", allocation_method: "method", priority: "priority",
+          provisional: "provisional", eligibility: "eligibility" }.each do |attr, key|
+          h[key] = public_send(attr) if public_send(attr)
+        end
+        h["allocations"] = allocations if allocations.any?
+        h
+      end
+    end
+
+    # schemas/shopping/types/postal_address.json — every field optional, so a
+    # partial address (e.g. locality/region/country only, before a full
+    # street address is known) is still schema-conformant.
+    PostalAddress = Data.define(:extended_address, :street_address, :address_locality, :address_region,
+                                :address_country, :postal_code, :first_name, :last_name, :phone_number) do
+      def initialize(extended_address: nil, street_address: nil, address_locality: nil, address_region: nil,
+                     address_country: nil, postal_code: nil, first_name: nil, last_name: nil, phone_number: nil)
+        super
+      end
+
+      def to_wire_h
+        { "extended_address" => extended_address, "street_address" => street_address,
+          "address_locality" => address_locality, "address_region" => address_region,
+          "address_country" => address_country, "postal_code" => postal_code, "first_name" => first_name,
+          "last_name" => last_name, "phone_number" => phone_number }.compact
+      end
+    end
+
+    # schemas/shopping/types/shipping_destination.json — postal_address plus a
+    # destination id (one of fulfillment.json's two FulfillmentDestination
+    # shapes, alongside RetailLocation below).
+    ShippingDestination = Data.define(:id, :address) do
+      def to_wire_h = address.to_wire_h.merge("id" => id)
+    end
+
+    # schemas/shopping/types/retail_location.json — the pickup counterpart to
+    # ShippingDestination; only `address` is optional.
+    RetailLocation = Data.define(:id, :name, :address) do
+      def initialize(id:, name:, address: nil) = super
+
+      def to_wire_h
+        h = { "id" => id, "name" => name }
+        h["address"] = address.to_wire_h if address
+        h
+      end
+    end
+
+    # schemas/shopping/types/fulfillment_option.json — a single priced choice
+    # within a FulfillmentGroup (e.g. "Standard Shipping $5", "Express $15").
+    FulfillmentOption = Data.define(:id, :title, :totals, :description, :carrier, :earliest_fulfillment_time,
+                                    :latest_fulfillment_time) do
+      def initialize(id:, title:, totals:, description: nil, carrier: nil, earliest_fulfillment_time: nil,
+                     latest_fulfillment_time: nil)
+        super
+      end
+
+      def to_wire_h
+        h = { "id" => id, "title" => title, "totals" => totals.map(&:to_wire_h) }
+        h["description"] = description if description
+        h["carrier"] = carrier if carrier
+        h["earliest_fulfillment_time"] = earliest_fulfillment_time if earliest_fulfillment_time
+        h["latest_fulfillment_time"] = latest_fulfillment_time if latest_fulfillment_time
+        h
+      end
+    end
+
+    # schemas/shopping/types/fulfillment_group.json — a merchant-generated
+    # package of line items; the agent sets `selected_option_id` on update to
+    # choose a shipping/pickup rate for that package.
+    FulfillmentGroup = Data.define(:id, :line_item_ids, :options, :selected_option_id) do
+      def initialize(id:, line_item_ids:, options: [], selected_option_id: nil) = super
+
+      def to_wire_h
+        { "id" => id, "line_item_ids" => line_item_ids, "options" => options.map(&:to_wire_h),
+          "selected_option_id" => selected_option_id }
+      end
+    end
+
+    # schemas/shopping/types/fulfillment_method.json — shipping or pickup for
+    # a subset of line items. The agent submits `type`/`line_item_ids` on
+    # create; the merchant fills in `destinations`/`groups` for the agent to
+    # then select `selected_destination_id` and each group's
+    # `selected_option_id` on update.
+    FulfillmentMethod = Data.define(:id, :type, :line_item_ids, :destinations, :selected_destination_id, :groups) do
+      def initialize(id:, type:, line_item_ids:, destinations: [], selected_destination_id: nil, groups: [])
+        super
+      end
+
+      def to_wire_h
+        h = { "id" => id, "type" => type, "line_item_ids" => line_item_ids }
+        h["destinations"] = destinations.map(&:to_wire_h) unless destinations.empty?
+        h["selected_destination_id"] = selected_destination_id if selected_destination_id
+        h["groups"] = groups.map(&:to_wire_h) unless groups.empty?
+        h
+      end
+    end
+
+    # schemas/shopping/types/fulfillment_available_method.json — an inventory
+    # availability hint (preorder/pickup-today/etc.), independent of whether
+    # the buyer has actually chosen that method yet.
+    FulfillmentAvailableMethod = Data.define(:type, :line_item_ids, :fulfillable_on, :description) do
+      def initialize(type:, line_item_ids:, fulfillable_on: nil, description: nil) = super
+
+      def to_wire_h
+        h = { "type" => type, "line_item_ids" => line_item_ids }
+        h["fulfillable_on"] = fulfillable_on if fulfillable_on
+        h["description"] = description if description
+        h
+      end
+    end
+
+    # schemas/shopping/fulfillment.json#/$defs/dev.ucp.shopping.fulfillment —
+    # the Checkout-level container. Named CheckoutFulfillment (not
+    # `Fulfillment`, already taken by Order's post-purchase expectations/
+    # events container below) to keep the pre-purchase shipping-selection
+    # extension and the post-purchase delivery-tracking extension distinct.
+    # The member is `shipping_methods`, not the wire key `methods` — a bare
+    # `:methods` Data.define member would shadow Kernel#methods.
+    CheckoutFulfillment = Data.define(:shipping_methods, :available_methods) do
+      def initialize(shipping_methods: [], available_methods: []) = super
+
+      def empty? = shipping_methods.empty? && available_methods.empty?
+
+      def to_wire_h
+        h = {}
+        h["methods"] = shipping_methods.map(&:to_wire_h) unless shipping_methods.empty?
+        h["available_methods"] = available_methods.map(&:to_wire_h) unless available_methods.empty?
+        h
+      end
+    end
+
+    # schemas/shopping/discount.json#/$defs/discounts_object — `codes` is the
+    # request-side input (case-insensitive, full-replacement — send [] to
+    # clear); `applied` is the response-side result. Both optional, so a Cart/
+    # Checkout with no discount activity omits the whole field (see Cart/
+    # Checkout#to_wire_h below), same posture as Order#adjustments.
+    Discounts = Data.define(:codes, :applied) do
+      def initialize(codes: [], applied: []) = super
+
+      def empty? = codes.empty? && applied.empty?
+
+      def to_wire_h
+        h = {}
+        h["codes"] = codes unless codes.empty?
+        h["applied"] = applied.map(&:to_wire_h) unless applied.empty?
+        h
+      end
+    end
+
     # schemas/shopping/cart.json — requires ucp/id/line_items/currency/totals.
     # The "ucp" envelope is added centrally by Portage::Ucp::WireEnvelope, not stored
     # on the value object itself.
-    Cart = Data.define(:id, :line_items, :currency, :totals) do
+    # `discounts` is the dev.ucp.shopping.discount extension (optional on both
+    # cart.json and its own schema) — omitted from the wire payload when empty,
+    # same as Order#adjustments.
+    Cart = Data.define(:id, :line_items, :currency, :totals, :discounts) do
+      def initialize(id:, line_items:, currency:, totals:, discounts: Discounts.new) = super
+
       def to_wire_h
-        { "id" => id, "line_items" => line_items.map(&:to_wire_h), "currency" => currency,
-          "totals" => totals.map(&:to_wire_h) }
+        h = { "id" => id, "line_items" => line_items.map(&:to_wire_h), "currency" => currency,
+              "totals" => totals.map(&:to_wire_h) }
+        h["discounts"] = discounts.to_wire_h unless discounts.empty?
+        h
       end
     end
 
@@ -78,13 +248,23 @@ module Portage
     # canceled) — not the old ad hoc "pending"/"completed" strings. `order` is
     # the schema's optional order_confirmation — set once complete_checkout
     # actually produces an order, nil otherwise.
-    Checkout = Data.define(:id, :status, :line_items, :currency, :totals, :links, :order) do
-      def initialize(id:, status:, line_items:, currency:, totals:, links:, order: nil) = super
+    # `discounts` — same dev.ucp.shopping.discount extension as Cart, above.
+    # `fulfillment` — the dev.ucp.shopping.fulfillment extension (optional,
+    # omitted from the wire payload when empty), same posture as
+    # Order#adjustments.
+    Checkout = Data.define(:id, :status, :line_items, :currency, :totals, :links, :order, :discounts,
+                           :fulfillment) do
+      def initialize(id:, status:, line_items:, currency:, totals:, links:, order: nil, discounts: Discounts.new,
+                     fulfillment: CheckoutFulfillment.new)
+        super
+      end
 
       def to_wire_h
         h = { "id" => id, "status" => status, "line_items" => line_items.map(&:to_wire_h),
               "currency" => currency, "totals" => totals.map(&:to_wire_h), "links" => links.map(&:to_wire_h) }
         h["order"] = order.to_wire_h if order
+        h["discounts"] = discounts.to_wire_h unless discounts.empty?
+        h["fulfillment"] = fulfillment.to_wire_h unless fulfillment.empty?
         h
       end
     end

data/lib/portage/ucp/version.rb

@@ -1,5 +1,5 @@
 module Portage
   module Ucp
-    VERSION = "0.1.0".freeze
+    VERSION = "0.2.0".freeze
   end
 end

data/lib/portage/ucp.rb

@@ -28,6 +28,8 @@ require_relative "ucp/capabilities/catalog"
 require_relative "ucp/capabilities/cart"
 require_relative "ucp/capabilities/checkout"
 require_relative "ucp/capabilities/order"
+require_relative "ucp/capabilities/discount"
+require_relative "ucp/capabilities/fulfillment"
 require_relative "ucp/capabilities/identity_linking"
 require_relative "ucp/capability_registry"
 require_relative "ucp/capability_negotiator"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: portage-ucp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tom Whitbread
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -138,7 +137,6 @@ dependencies:
         version: '0.9'
 description: 'Protocol-only core gem: Adapter contract, capability registry, manifest
   builder, and an MCP server wrapper. No commerce-backend deps.'
-email:
 executables:
 - portage-ucp-check
 extensions: []
@@ -154,6 +152,8 @@ files:
 - lib/portage/ucp/capabilities/cart.rb
 - lib/portage/ucp/capabilities/catalog.rb
 - lib/portage/ucp/capabilities/checkout.rb
+- lib/portage/ucp/capabilities/discount.rb
+- lib/portage/ucp/capabilities/fulfillment.rb
 - lib/portage/ucp/capabilities/identity_linking.rb
 - lib/portage/ucp/capabilities/order.rb
 - lib/portage/ucp/capability.rb
@@ -261,7 +261,6 @@ metadata:
   source_code_uri: https://github.com/tomtom87/Portage/tree/main/portage-ucp
   changelog_uri: https://github.com/tomtom87/Portage/blob/main/portage-ucp/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -276,8 +275,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.18
 specification_version: 4
 summary: Expose a commerce backend to AI shopping agents over MCP and UCP
 test_files: []