@@ -97,6 +97,7 @@ The frozen vocabulary comes from the spec's `reason-codes.json`, packaged with t
 | `outside_flight` | not owed | flight | Not owed: the period ends {end}, at or before {buy} starts at {start_time}. |
 | `after_stop` | not owed | flight | Not owed: the period starts {start}, at or after {buy} stopped at {stop_time}. |
 | `before_confirmation` | not owed | confirmation | Not owed: the period ends {end}, before {buy} was confirmed at {confirmed_at}. |
+| `before_package_added` | not owed | confirmation | Not owed: the period ends {end}, by {added_at}, before any package of {buy} resolving {offering} was added to it. |
 | `excluded:capacity` | not owed | exception | Not owed: account {account} is beyond the seller's subscription capacity from {from}. |
 | `excluded:overridden` | not owed | exception | Not owed: another of the caller's delivery configurations takes {account} for this feed from {from}. |
 | `excluded:action_required` | not owed | exception | Not owed: the seller serves account {account} only after a pending action completes; excluded from {from}. |
@@ -120,6 +121,14 @@ A period that ends at or before the buy's `confirmed_at` is not owed (`before_co
 >
 > Owed: mb_123 under daily_pkg for the period 2026-11-04T05:00Z to 2026-11-05T05:00Z, due at 2026-11-05T11:00Z.
 
+### A package added later
+
+A package added to a confirmed buy carries `added_at` on `get_media_buys` (3.3.0-beta.4), and `added_at` is that package's own `confirmed_at`. Each package is owed from the later of the buy's `confirmed_at` and its `added_at` (`confirmed_at` alone when `added_at` is absent: the package was part of the buy at confirmation). The buy owes a period of an offering when the period ends after that instant for at least one package resolving the offering. So the period containing `added_at` is owed in full, earlier periods are owed only through packages the buy already had, and adding a package is never a cutover. When every package resolving the offering was added after the period ended, the reason is `before_package_added`.
+
+The package also resolves at the later of the version's `accepted_at` and its own `confirmed_at`, among the offerings available then. A `package_ids` exception removes a period when it names every package resolving the offering that is owed that period, so packages added and removed compose: a package keeps the buy covered from its `added_at` until an entry naming it takes it out.
+
+`SubscriptionBuy.from_media_buy` reads `packages[].added_at` into `SubscriptionBuyPackage.added_at`, and `SubscriptionBuy.package_confirmed_at(package_id)` is the instant it is owed from.
+
 ### Cancellation mid-period
 
 A buy stops at the earliest of `end_time`, the cancellation's delivery stop and `completed_at`. The delivery stop is `cancellation_effective_at` when the seller delivers through a notice period, else `cancellation.canceled_at` (3.3.0-beta.3). A period that starts at or after the stop is not owed (`after_stop`). The period containing the stop is owed in full. Flight values are read as of each period's end from the buy's `flight_history`, so a retroactive edit never makes an elapsed period owed.
@@ -150,7 +159,7 @@ When a cutover hands a billing feed to a schedule with no boundary at E, the str
 
 ### Sticky resolution
 
-A package resolves once, when its (buy, version) pair first does: at the later of the version's `accepted_at` and the buy's `confirmed_at`, among the offerings available then. An offering published later never re-resolves it. A resolved offering's `withdrawn_at` is the one change: the package re-resolves among the offerings available then, as a cutover.
+A package resolves once, when its (buy, version) pair first does: at the later of the version's `accepted_at` and the package's own `confirmed_at` (the buy's, or its `added_at` when later), among the offerings available then. An offering published later never re-resolves it. A resolved offering's `withdrawn_at` is the one change: the package re-resolves among the offerings available then, as a cutover.
 
 ### Reactivation
 
@@ -160,4 +169,8 @@ Coverage resumes at the first boundary at or after the later of the reactivation
 
 > Owed: mb_1 under off_e_pkg_acct_tz for the period 2026-11-01T04:00Z to 2026-11-02T05:00Z, due at 2026-11-02T11:00Z.
 
-That New York day is 25 hours long. `P1D` periods follow the local calendar, so DST days are 23 or 25 hours long. Under a local alignment each local date's first instant is always a boundary: local midnight, or the first instant after a DST gap at midnight (Havana, Santiago, Cairo). Days therefore nest in every sub-daily schedule, and `PT24H` equals `P1D`. Under `utc`, `PT24H` periods are always 24 hours. A sub-daily `billing_cycle` is refused (`invalid_period_duration`).
+That New York day is 25 hours long. `P1D` periods follow the local calendar, so DST days are 23 or 25 hours long. Under a local alignment each local date's first instant is always a boundary: local midnight, or the first instant after a DST gap at midnight (Havana, Santiago, Cairo). Days therefore nest in every sub-daily schedule, and `PT24H` equals `P1D`. Under `utc`, `PT24H` periods are always 24 hours. A sub-daily `billing_cycle` is refused (`invalid_period_duration`). Under a local alignment a duration cannot mix date and time components (`P1DT12H`); since 3.3.0-beta.4 the schedule schemas reject it too, while `P1DT0H`, `P0DT12H` and any duration under `utc` stay valid.
+
+### Time zones
+
+Zones come from Python's `zoneinfo`, so periods follow the IANA tzdata the host resolves: the system database, or the `tzdata` package where there is none (Windows). The spec's vectors are derived with tzdata 2026f over the whole database, including southern-hemisphere DST (Pacific/Auckland), a 45-minute offset (Pacific/Chatham), half-hour offsets (Asia/Kolkata) and the 2022 rule change in America/Mexico_City. Their dates are chosen where releases 2026b through 2026f agree, so any of those reproduces them; `tests/test_reporting_subscription_parity.py` pins `tzdata==2026.6` (2026f) and ignores the host's database. Run buyer and seller on the same tzdata release, or a current one, so both derive the same boundaries.
@@ -24,13 +24,17 @@ The SDK reads these surfaces under each principal's identity. A principal sees e
 | Input | Read from | Must be present | Override |
 |---|---|---|---|
 | Authorized accounts | `list_accounts` (a decisioning platform's `accounts.list`) | `account_id`, `timezone` (IANA), `operator`, `authorization.allowed_tasks` | `SubscriptionOptions.accounts` |
-| Visible buys | `get_media_buys` | `confirmed_at`, `start_time`, `end_time`, `cancellation.canceled_at`, `cancellation_effective_at`, `completed_at`, `flight_history`, `packages[].package_id` | `SubscriptionOptions.buys` |
+| Visible buys | `get_media_buys` | `confirmed_at`, `start_time`, `end_time`, `cancellation.canceled_at`, `cancellation_effective_at`, `completed_at`, `flight_history`, `packages[].package_id`, and `packages[].added_at` on every package added after `confirmed_at` (3.3.0-beta.4) | `SubscriptionOptions.buys` |
 | Package offerings | `packages[].reporting_delivery_offering_ids` (fixed at confirmation; `[]` means none), else, only when the seller omits it, every registered offering | | `SubscriptionOptions.buy_offerings` |
-| Offerings | `capability_offerings` on each registered source | `standard_dimensions` on every offering; `available_from` / `withdrawn_at` when they apply; `account_id` in `reporting_profile.primary_keys` on every offering delivered to destinations (`method`), required by 3.3.0-beta.3 and logged as `reporting.subscription.offering_primary_keys` when missing | none |
+| Offerings | `capability_offerings` on each registered source | `standard_dimensions` on every offering (else `SUBSCRIPTIONS_REQUIRE_STANDARD_DIMENSIONS`); `available_from` / `withdrawn_at` when they apply; on every offering delivered to destinations (`method`), `account_id` in `reporting_profile.primary_keys` and a row schema that declares `account_id` as a required string (else `SUBSCRIPTIONS_REQUIRE_ACCOUNT_ID_KEY`, refused at configuration since 3.3.0-beta.4) | none |
 | Report content | `account_context`, called with `configuration.subscription` set | | `SubscriptionOptions.configure` |
 
 A decisioning `Account` carries `timezone=` and `operator=`. An account without a timezone is refused rather than read as UTC.
 
+A host that supplies `SubscriptionOptions.buys` builds each `SubscriptionBuyPackage` with `added_at` for a package added after the buy's `confirmed_at`; one served through `get_media_buys` keeps it from the wire, also under `buy_offerings`. Without it the package reads as part of the buy at confirmation, which owes it periods it was never in.
+
+`check_subscription_offerings(offerings, row_schemas)` runs the offering checks of the spec's `offering-checks.json` and returns every failure in offering order. Each failure's `.error()` is the `ReliableReportingConfigurationError` (`code`, `config_field`, and `context` with `offering_id` and `missing`: `primary_key` or `row_schema`). The service runs it on the registered offerings without row schemas; pass the row schemas you fetched to check those too.
+
 ### Capabilities and serving
 
 The service fills in what it serves and leaves the rest to you:
@@ -45,14 +49,15 @@ The service fills in what it serves and leaves the rest to you:
 
 The reference seller (`python -m adcp reference-seller reporting`) is a complete example.
 
-## AdCP 3.3.0-beta.3 rules the engine applies
+## AdCP 3.3 rules the engine applies (3.3.0-beta.3 and beta.4)
 
 - **Admission under `max_accounts`.** Candidates are ordered by `authorization.authorized_at`, then `account_id` in byte order, and an admitted account keeps its slot. A waiting candidate carries a `capacity` exception.
 - **Several feeds per purpose.** A caller may hold several pacing or analytics subscriptions for one account. Where two resolve the same offering for a package, the lowest `subscription_id` owes it and the other records an `overridden` exception naming the `package_ids`. Billing stays one per account at a scope level.
 - **Membership in place.** Membership edits (`account_ids`, `exclude_account_ids`) keep the version. A removed account stays listed, `excluded`, with an `excluded_by_buyer` entry from the cutover. An added account gets a closed entry covering the time before it joined.
 - **`destination_overrides`.** An account named by an override, by `account_ids` or `operator_domains`, resolves against the override's destination method. Its owed sets carry the override as the version's `destination`, so `bind_managed_generation` binds and checks the override's `path_template`.
 - **Bounded readback.** `prior_versions` lists the 16 newest inline, and the account lists 1,000, each with a total count. `get_principal` `reporting_subscription_page` pages the rest from the engine's state.
 - **Partial grants.** A grant that keeps the account covered refuses a task it does not list with `SCOPE_INSUFFICIENT`.
+- **Reduced grants (3.3.0-beta.4).** A grant reduced to `allowed_tasks` without `get_reporting_status` ends the caller's reporting authority exactly as a revocation does, at the reduction: the account is listed in `accounts_unauthorized` with that instant as `unauthorized_at`, nothing is delivered for periods ending after it, and owed periods not delivered by then are withheld. The account stays visible to the tasks the grant lists, so `get_reporting_status` refuses it with `SCOPE_INSUFFICIENT`, as for any task the grant omits; only a revoked account is unknown (`ACCOUNT_NOT_FOUND`). Adding `get_reporting_status` back is a re-grant for every rule: the chain, `regranted_at`, gaps, `backfill_on_regrant` and admission. A reduction that keeps `get_reporting_status` is not a loss of authority.
 - **Billing stubs and `regranted_at`.** A billing cutover owes a stub obligation (`stub: true`), and `list_accounts` serves `authorization.regranted_at`.
 
 The reference seller, `adcp.testing.reporting.create_reference_reporting_seller`, is a complete example on this path. A ~100-line handler serves `list_accounts` and `get_media_buys`, and `ReliableReportingService(subscriptions=SubscriptionOptions(...))` adds the rest. Run it with `python -m adcp reference-seller reporting`; see [Testing](reporting-subscriptions-testing.md#the-reference-seller).
@@ -91,7 +96,7 @@ The SDK is the only source of `authorization.authorized_at`.
 
 `authorized_at` is when the *current authorization chain* began, not when access was last granted. Never set it to "now" on a re-grant, and never move it earlier.
 
-**Wind down, don't revoke.** Revocation means no access at all, receipts and statuses included. To end a relationship while the buyer finishes reconciling:
+**Wind down, don't revoke.** Revocation means no access at all, receipts and statuses included. A reduction that drops `get_reporting_status` ends reporting authority the same way, though the account stays visible to the tasks it keeps (`SCOPE_INSUFFICIENT`, not unknown). To end a relationship while the buyer finishes reconciling, keep `get_reporting_status`:
 
 ```python
 from adcp.server import wind_down_grant
 
@@ -28,9 +28,9 @@ async with reporting_test_kit(
 ```
 
 - **Clock.** `kit.clock.advance("P3D")` (days to seconds) and `advance_to(instant)` move the one virtual clock forward. At every period boundary crossed, the seller processes the move as production would: the boundary sweep, then planning.
-- **Grants, accounts and buys.** `kit.grants` (`revoke`, `regrant`, `reduce`, `wind_down`), `kit.accounts.set_timezone` and `kit.buys` (`add`, `cancel`) go through the controller's `reporting_subscription_probe` and `seed_media_buy`. That is the same scenario a storyboard drives against a remote seller.
+- **Grants, accounts and buys.** `kit.grants` (`revoke`, `regrant`, `reduce`, `wind_down`), `kit.accounts.set_timezone` and `kit.buys` (`add`, `add_package`, `cancel`) go through the controller's `reporting_subscription_probe` and `seed_media_buy`. That is the same scenario a storyboard drives against a remote seller. `add_package` adds a package to a confirmed buy now (or `at=`), so `get_media_buys` serves it with `added_at` (3.3.0-beta.4).
 - **Agreement.** `await kit.assert_agreement(principal)` checks that the seller's owed set equals what the buyer's `reconcile()` computes over the wire. It also checks that the `authorized_at` served on `list_accounts` is the one coverage used. On a difference, the `AgreementError` names each disputed period, the first rule at which the two `CoverageTrace`s differ, and both sentences.
-- **Your platform.** Pass `platform=` (your installed handler), `service=` (your `ReliableReportingService`) and `controller=` (a `TestControllerStore` serving `reporting_subscription_probe` and `seed_media_buy`). The kit then drives your seller through that controller.
+- **Your platform.** Pass `platform=` (your installed handler), `service=` (your `ReliableReportingService`) and `controller=` (a `TestControllerStore` serving `reporting_subscription_probe`, `reset_state` and `seed_media_buy`). The kit then drives your seller through that controller.
 - **Offerings.** `offerings.daily_analytics(...)` and `offerings.hourly_pacing(...)` build offering fixtures that publish `standard_dimensions`.
 
 ## The test kit
@@ -68,13 +68,19 @@ npx adcp storyboard run https://seller.example/mcp --storyboards reporting_subsc
 - Storage is process-local.
 - The virtual clock starts at `--start` (default: now) and moves only through `comply_test_controller`.
 
-Its controller serves `seed_media_buy` and the `reporting_subscription_probe` scenario:
-- `revoke_grant`;
+Its controller serves `seed_media_buy`, `reset_state` and the `reporting_subscription_probe` scenario. Each probe result is `SimulationSuccess.simulated`, with `simulated_now` and `account_id`:
+- `revoke_grant`, which returns `unauthorized_at`;
 - `regrant`, which returns `chain`, `authorized_at` and `regranted_at`;
-- `reduce_grant`;
-- `set_account_timezone`, which returns `previous_timezone` and the cutovers;
+- `reduce_grant`, which returns the applied `allowed_tasks`. A list without `get_reporting_status` is a loss of authority at the reduction, and adding it back is a re-grant;
+- `set_account_timezone`, which returns `SetAccountTimezoneResult` (3.3.0-beta.4): `previous_timezone`, `timezone`, `changed_at` when the zone changed, and one `timezone_cutovers[]` entry per `account_timezone` offering, whose `effective_at` is the end of its last old-zone period that started before `changed_at`. Naming the current zone changes nothing: no `changed_at`, no cutovers;
 - `advance_time`, which processes every period boundary crossed.
 
+`reset_state` (3.3.0-beta.4) unpins the clock, so `simulated_now` reads the wall clock until the next `advance_time`. It also keeps every account the caller's probe acted on with its full default grant, restarting at the reset, and its timezone from before the probe first changed it, with nothing the probe recorded left in `accounts_unauthorized[]`, `gaps[]` or `timezone_cutovers[]`. The reference seller runs one clock for every principal, so unpinning it is seen by every caller.
+
+### Your controller
+
+A `TestControllerStore` that implements `reporting_subscription_probe` must also implement `reset_state`: AdCP 3.3.0-beta.4 requires a seller listing the probe to list it, and `register_test_controller` (and the A2A server) refuse a store without it with `ConfigurationError`. A runner calls `reset_state` once before each storyboard. Return the probe's result fields; the dispatcher nests a result without `simulated` under it, as `SimulationSuccess` requires.
+
 It passes the TypeScript `reporting_subscriptions` storyboard (15 steps, strict schema checks):
 
 ```
 
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable, Callable, Mapping
 from typing import Literal, TypeVar
 
 from adcp.exceptions import ADCPTaskError
@@ -66,6 +66,7 @@
         "REPORTING_STORAGE_NOT_DURABLE",
         "REPORTING_SCHEMA_BEHIND",
         "SUBSCRIPTIONS_REQUIRE_STANDARD_DIMENSIONS",
+        "SUBSCRIPTIONS_REQUIRE_ACCOUNT_ID_KEY",
         "SUBSCRIPTION_ROSTER_UNAVAILABLE",
     }
 )
@@ -80,10 +81,12 @@ class ReliableReportingConfigurationError(ValueError):
     ``code`` is set for the seller configuration codes of the cross-SDK
     vocabulary (``REPORTING_STORAGE_NOT_DURABLE``, ``REPORTING_SCHEMA_BEHIND``,
     ``SUBSCRIPTIONS_REQUIRE_STANDARD_DIMENSIONS``,
-    ``SUBSCRIPTION_ROSTER_UNAVAILABLE``); those carry ``recovery="correctable"``
-    and a message whose last sentence is the fix; ``config_field`` names the
-    configuration key to change. ``dispatched`` is always ``None``: a
-    configuration check sends nothing.
+    ``SUBSCRIPTIONS_REQUIRE_ACCOUNT_ID_KEY``, ``SUBSCRIPTION_ROSTER_UNAVAILABLE``);
+    those carry ``recovery="correctable"`` and a message whose last sentence is
+    the fix; ``config_field`` names the configuration key to change, and
+    ``context`` carries the code's ``error-codes.json`` context (for
+    ``SUBSCRIPTIONS_REQUIRE_ACCOUNT_ID_KEY``, ``offering_id`` and ``missing``).
+    ``dispatched`` is always ``None``: a configuration check sends nothing.
     """
 
     dispatched = None
@@ -95,6 +98,7 @@ def __init__(
         kind: Literal["misconfiguration", "auth_required", "invalid_request"] = "misconfiguration",
         code: str | None = None,
         config_field: str | None = None,
+        context: Mapping[str, str] | None = None,
     ) -> None:
         super().__init__(message)
         if code is not None and code not in SELLER_CONFIGURATION_CODES:
@@ -103,6 +107,8 @@ def __init__(
         self.code = code
         #: The configuration key to change (the TypeScript SDK's ``configField``).
         self.config_field = config_field
+        #: The code's ``error-codes.json`` context, when it defines one.
+        self.context: dict[str, str] = dict(context or {})
         self.recovery: Literal["correctable", "terminal"] | None = (
             "correctable" if code is not None else None
         )