@@ -17,6 +17,7 @@ changes below before upgrading each client, server and reporting worker.
 | Format-kind fields preserve open strings | Replace enum identity comparisons with string equality. Opt into `CanonicalFormatKindStr` when your application needs a closed vocabulary. See [format-kind validation](docs/canonical-format-kinds-migration.md). |
 | Reporting generations require authenticated caller ownership | Include `consumer_id` in custom store/binding implementations and typed constructors. Migrate populated ledgers with stopped workers; an entirely empty ledger can use the explicit replacement API. See [reporting ownership migration](docs/reporting-caller-ownership-migration.md). |
 | New source requests and sealed artifacts include their owning consumer | Read `request.identity.consumer_id` when implementing adapters. Historical ownerless artifacts retain their original hashes, but active owned generations refuse ownerless or differently owned frozen acquisitions; reconcile retained state and admit a new generation instead of relabelling evidence. See [reporting ownership migration](docs/reporting-caller-ownership-migration.md). |
+| URL canonicalization gives an empty path its `/` whatever the query does | The `@target-uri` signature base changes for bare-authority URLs such as `https://seller.example.com`. Dial signed clients at the explicit root path, which canonicalizes identically on both versions, or move an unrespellable agent URL's signer and verifier in one window. Identifier matching on `adagents.json`, `brand.json`, TMP and the governance issuer only becomes more permissive. See [the empty-path canonicalization fix](docs/request-signing-migration.md#6-upgrading-across-the-empty-path-canonicalization-fix). |
 | Initial automatic source reads default to a deterministic five-minute jitter window | Reads wait for the selected offering's declared availability and then spread within the available delivery headroom. Configure `read_jitter_window=timedelta(0)` to opt out. Pass an explicit window to custom producer factories only when they accept and forward the new keyword. Manual acquisitions, persisted retries and official-close timing retain their behavior. See [reporting service timing](docs/reliable-reporting-service.md). |
 
 The credential rule applies to all configured carriers, including opted-in
 
@@ -314,6 +314,33 @@ Ordering is different — the old kid must stop being trusted *before* anything
 - [ ] Redirect-following is disabled on every signing client.
 - [ ] Clock sync monitoring is in place on signer and verifier hosts.
 
+## 6. Upgrading across the empty-path canonicalization fix
+
+`canonicalize_target_uri` substitutes `/` for an empty path whenever an authority is present, which is what step 5 of the [AdCP URL-canonicalization algorithm](https://github.com/adcontextprotocol/adcp/blob/main/docs/reference/url-canonicalization.mdx) and RFC 3986 §6.2.3 require. Earlier releases applied the substitution only when the URL also carried a query string, so an empty path kept its emptiness unless a `?x=1` followed it:
+
+| URL dialled | Earlier releases | This release |
+| --- | --- | --- |
+| `https://seller.example.com` | `https://seller.example.com` | `https://seller.example.com/` |
+| `https://seller.example.com:8443` | `https://seller.example.com:8443` | `https://seller.example.com:8443/` |
+| `https://[2001:db8::1]` | `https://[2001:db8::1]` | `https://[2001:db8::1]/` |
+| `http://seller.example.com:80` | `http://seller.example.com` | `http://seller.example.com/` |
+| `https://seller.example.com?` | `https://seller.example.com?` | `https://seller.example.com/?` |
+
+A URL with any non-empty path, and `https://seller.example.com?x=1`, canonicalize exactly as they did before.
+
+### On the signing path
+
+`@target-uri` is part of the signature base, so for the URLs above the signed bytes change. A signer on this release and a verifier on an earlier one — or the reverse — derive different bases for the same request, and verification fails with `request_signature_invalid`. Nothing in that error names canonicalization, so sequence the upgrade rather than diagnosing it afterwards.
+
+Two ways across:
+
+- **Dial the explicit root path.** `https://seller.example.com/` canonicalizes to `https://seller.example.com/` on every release, before and after this change. Point signed clients at the URL with its path spelled out and both versions derive the same base, so signer and verifier upgrade independently and in any order. Worth making permanent: an agent URL registered with its path never depended on the fix.
+- **Upgrade both ends together.** For an agent URL you cannot respell, move its signer and its verifier in one window the way you would a key rotation, or hold the affected operation at `warn_for` (§2, step B) across the window so a base mismatch logs instead of rejecting.
+
+### Off the signing path
+
+The same function is the identifier comparer for `adagents.json` `authorized_agents[].url`, `brand.json` `agents[].url`, TMP `seller_agent.agent_url`, `format-id.agent_url` and the governance issuer. There the change is strictly more permissive: `https://agent.example.com` and `https://agent.example.com/` now compare equal, where before a publisher who registered the first did not match a caller who arrived as the second, and the refusal named authorization rather than canonicalization. No registration needs editing, and no pair that matched before stops matching.
+
 ## Related
 
 - [`adcp.signing.install_signing_event_hook`](../src/adcp/signing/client.py) — buyer-side preset for adapters not using `ADCPClient`.
 
@@ -122,7 +122,12 @@ def canonicalize_target_uri(url: str) -> str:
     scheme = parts.scheme.lower()
     netloc = _canon_authority(parts.netloc, scheme)
     path = _normalize_path(parts.path)
-    if not path and parts.query:
+    if not path:
+        # Step 5: an empty path with an authority present canonicalizes to "/"
+        # (RFC 3986 §6.2.3). The condition is the path and the authority, never
+        # the query: `https://host` takes the slash exactly as `https://host?x=1`
+        # does. `_canon_authority` above has already rejected an authority with
+        # no host, so reaching this line guarantees one is present.
         path = "/"
     # RFC 9421 §2.2.2 + RFC 7230 §5.5: effective request URI excludes the
     # fragment (client-local, never sent on wire).
 
@@ -264,3 +264,83 @@ def test_non_digit_port_is_rejected_with_the_spec_code(url: str) -> None:
     with pytest.raises(ValueError) as excinfo:
         canonicalize_authority(url)
     assert getattr(excinfo.value, "code", None) == "request_target_uri_malformed"
+
+
+# ---- step 5: empty path + authority -> "/", whatever the query does ----
+
+
+@pytest.mark.parametrize(
+    ("url", "expected"),
+    [
+        # The canonicalization.json case, kept here so the no-query rows below
+        # are read against the one spelling the vector set already pins.
+        ("https://seller.example.com?x=1", "https://seller.example.com/?x=1"),
+        # No query at all -- the rows the vector set does not reach.
+        ("https://seller.example.com", "https://seller.example.com/"),
+        ("https://seller.example.com:8443", "https://seller.example.com:8443/"),
+        ("https://[2001:db8::1]", "https://[2001:db8::1]/"),
+        ("http://seller.example.com:80", "http://seller.example.com/"),
+        # Empty query, i.e. a bare trailing "?". Step 5 supplies the slash and
+        # step 7 keeps the "?"; the two rules compose rather than compete.
+        ("https://seller.example.com?", "https://seller.example.com/?"),
+    ],
+    ids=[
+        "query",
+        "no-query",
+        "no-query-port",
+        "no-query-ipv6",
+        "no-query-default-port",
+        "empty-query",
+    ],
+)
+def test_empty_path_with_authority_becomes_slash_regardless_of_query(
+    url: str, expected: str
+) -> None:
+    """Step 5 keys on the path and the authority, never on the query.
+
+    The spec's step 5 reads "If the path is empty AND an authority is present,
+    substitute `/`"; the query appears only inside its illustrative example
+    (`https://host?x=1` -> `https://host/?x=1`). RFC 3986 §6.2.3 is the same --
+    scheme-based normalization gives an authority-bearing hierarchical URI the
+    `/` path whether or not a query follows.
+
+    This was implemented as `if not path and parts.query`, so `https://host`
+    canonicalized to `https://host` and only the queried spelling got its
+    slash. `canonicalization.json` could not catch it: of its 37 cases exactly
+    one has an empty path, and that one carries `?x=1`. The empty-query row is
+    the same gate failing on its own terms -- `https://host?` has a `?` in the
+    raw URL but `urlsplit` reports `query == ""`, so the condition read False
+    and the output was `https://host?`, a path-less URI no RFC 3986 normalizer
+    produces.
+
+    Both consequences are silent until they are not. On the signing path a
+    producer applying step 5 and a comparer skipping it derive different
+    `@target-uri` bytes for one URL, and every signature between them fails
+    verification with nothing in either log naming the cause. Off the signing
+    path the same function is the identifier comparer for `adagents.json`
+    `authorized_agents[].url`, `brand.json` `agents[].url`, TMP
+    `seller_agent.agent_url` and the governance issuer, which is what
+    `test_bare_authority_and_trailing_slash_are_one_identifier` pins.
+    """
+    assert canonicalize_target_uri(url) == expected
+
+
+def test_bare_authority_and_trailing_slash_are_one_identifier() -> None:
+    """`https://host` and `https://host/` are the same URL, so one canonical form.
+
+    Stated as a relationship rather than literals: what matters is that the two
+    spellings converge, not which string they converge on. Before step 5 ran
+    unconditionally they did not, and because this canonicalizer is shared by
+    every URL-identifier surface in the SDK -- not just `@target-uri` -- a
+    publisher who registered an agent as `https://agent.example.com` failed to
+    match a caller arriving as `https://agent.example.com/`, and the rejection
+    named authorization rather than canonicalization.
+    """
+    for bare in (
+        "https://agent.example.com",
+        "https://agent.example.com:8443",
+        "https://[2001:db8::1]",
+    ):
+        assert canonicalize_target_uri(bare) == canonicalize_target_uri(
+            f"{bare}/"
+        ), f"bare authority and trailing slash diverge for {bare!r}"