# AgentGuard gate: the guarantees, checked on every change

AgentGuard's hosted gate (`POST /api/gate/authorize`) sits between an AI agent and an action that moves money or contacts a person. Before a refund, a credit, a fee waiver, a payout, a call or a text, the agent asks the gate, and the gate answers **allow**, **escalate** (hold it for a person) or **block**, with a signed receipt. The decision is ordinary deterministic code. No language model is in the loop, so a decision costs no tokens and the same request under the same policy and the same counters always gets the same answer.

This file lists what the gate guarantees. Each guarantee has an id and one property test in this folder. A property test does not check a handful of examples: it generates thousands of requests (policies, actions, amounts, risk scores, payees, recipients, time zones, timestamps, and orders of concurrent requests) and runs each one through the real gate code, the same handlers that serve agentguard.run, asserting the guarantee every time. CI runs the whole suite on every pull request. A change that breaks a guarantee fails the `gate-invariants` check.

## The guarantees

| ID | Guarantee | Property test |
|---|---|---|
| G01 | A block or escalate decision never executes or signs an allow. | `g01-hold-never-allows.test.cjs` |
| G02 | A caller's risk score can only make a decision stricter, never looser, for any policy and request. | `g02-risk-only-tightens.test.cjs` |
| G03 | The money window cap is never exceeded, even with many allows racing at once. | `g03-window-cap-under-races.test.cjs` |
| G04 | Once a policy is pinned on a vendor key, a policy sent in the request never changes the decision, and the receipt says the request policy was ignored. | `g04-pinned-policy-wins.test.cjs` |
| G05 | Per-recipient contact caps, the fleet contact cap and calling windows are never exceeded or bypassed, across time zones; a contact to an unknown time zone is held, not guessed. | `g05-contact-caps-and-windows.test.cjs` |
| G06 | A contact in a category the recipient opted out of is always refused. | `g06-opt-out-refuses.test.cjs` |
| G07 | A request carrying a content field, or text over the length limit, is refused, exactly as the /vendors terms define both. | `g07-content-refused.test.cjs` |
| G08 | Every signed receipt verifies with the published key, and changing any one field of it makes verification fail. | `g08-receipts-verify.test.cjs` |
| G09 | An action with no matching rule is blocked (default deny), and a claimed capability below the rule's requirement is blocked. | `g09-default-deny.test.cjs` |
| G10 | Only money going out counts toward caps; a payment taken in never does. | `g10-only-money-out-counts.test.cjs` |
| G11 | A held action becomes an allow only through the approver's own link, before it expires, and is decided once. | `g11-approval-once-by-the-approver.test.cjs` |
| G12 | The approver is the operator's setting, never the agent's, and the approval link never goes back to the agent that asked. | `g12-approver-set-by-operator.test.cjs` |
| G13 | A payee or customer reference never appears in the clear in a receipt, a response or anything the gate stores. | `g13-identifiers-stay-hashed.test.cjs` |
| G14 | Without a vendor key the gate is a sandbox: it stores nothing, counts nothing and never speaks for a real tenant. | `g14-sandbox-stores-nothing.test.cjs` |
| G15 | The gate fails closed: if it cannot read or write its store, or cannot sign, the answer is block; a paused tenant is blocked for everything. | `g15-fail-closed.test.cjs` |
| G16 | With a vendor key the gate counts and keeps time itself: spend, contact counts and times the caller sends never change a decision. | `g16-gate-counts-and-keeps-time.test.cjs` |
| G30 | An action names itself with plain codes: a type that is not a string, a currency that is not a three-letter code or a target system that is not a short code is refused, and nothing is decided, signed or stored from it. | `g30-g32-audit-nov9.test.cjs` |
| G31 | While a tenant is paused, a hold that was already waiting cannot be approved or denied; no receipt is signed for it until the pause is lifted. | `g30-g32-audit-nov9.test.cjs` |
| G32 | At a recipient's contact cap, the counts a caller sends never change the keyed decision (the contact half of G16, reached on purpose). | `g30-g32-audit-nov9.test.cjs` |
| G33 | An amount above a rule's `auto_approve_max_cents` is never allowed without a person: it is held, or refused by a stricter limit. | `g33-g34-audit-nov9.test.cjs` |
| G34 | Words an agent chose never reach the person who decides: the approval email, text message and page show the operator's own label for the tenant, and the agent's id only as a labelled code, never inside a sentence. | `g33-g34-audit-nov9.test.cjs` |

G01 to G10 were set as the minimum on Nov 3 2026. G11 to G16 are further promises the gate's code and documentation make, added because they can be checked the same way.

### What each property checks

**G01.** Requests of every kind go through the gate: money and contact, with a vendor key and a request policy, with a pinned policy, and in sandbox. For every answer that is not an allow, the signed receipt carries the same decision, says the action is not permitted, reserves nothing, and the gate's counters are exactly as they were before. A hold opens a pending approval and nothing else. The same receipt is then offered to `POST /api/gate/outcomes` as the authority for an executed action and must be refused there too. No answer other than 200 ever carries an allow.

**G02.** Each request is decided twice: as generated, with the policy's risk thresholds and the action's score, and with every risk setting and the score removed. With the order allow, then escalate, then block, the first decision is never below the second; when they are equal the reason is the same; a block stays the same block. A second property sends the same request with two scores and checks the higher score never gets a looser answer.

**G03.** Up to six payouts start at the same moment on one or two vendor keys of one tenant, after earlier payouts have spent part of the window. The test holds every store operation they make and lets fast-check choose the order they run in, one at a time (see "How the suite works"). The keys' window cap, sometimes a tenant-wide money cap and a per-payee count cap must all hold, the stored counters must equal exactly what was allowed (nothing lost, nothing counted twice), and a request that could not win its writes is answered block, never allow. It runs on the in-memory store and on a real Redis with the production compare-and-set.

**G04.** A generated policy is pinned on two fresh keys. The same action goes to one key with a policy in the request (another generated policy, or the pinned one with every limit removed) and to the other with none. Status, decision, reason and the hash of the deciding policy must match, and that hash is the pinned policy's. The receipt says `policy_source: "pinned"` and `request_policy_ignored: true` exactly when a policy was sent. A key marked `require_pinned_policy` with nothing pinned refuses every request.

**G05.** Calling windows: a contact at a generated instant (weighted toward daylight-saving changes, the date line, and zones with half-hour and 45-minute offsets) under windows set at the policy and rule level, by purpose, with days and skip dates, placed around the recipient's local time so the edges are hit. A reference written from the documented rules decides which window applies and whether the instant is inside it. An allowed contact is always inside; one outside is blocked with the matching reason; with a time zone the platform cannot resolve, the contact is held for a person and the receipt records no zone and no local time. With a vendor key, a time named in the request is ignored. Caps: sequences of contacts minutes to days apart; in every rolling 24 hours and 7 days a recipient never passes its caps, and the tenant never passes its daily cap, and every decision matches a reference count. Races: concurrent contacts on the in-memory store and on a real Redis never pass a cap.

**G06.** A contact whose recipient opted out of its purpose, or of everything, is blocked: never allowed, never held for a person to approve. With opt-outs on file and no purpose sent, the contact is never allowed.

**G07.** The terms on /vendors say the server refuses a request, and stores nothing from it, when a field at the top level or nested up to four objects deep is named `prompt`, `completion`, `content`, `messages`, `input`, `output`, `text`, `customer`, `pii`, `card`, `pan`, `phone`, `phone_number`, `email_body` or `transcript`, in any letter case, or when any string in it is longer than 256 characters. The property checks exactly that: a valid request gets one piece of content planted under the body, the action or the policy, inside further objects and lists, either a content-named field anywhere the terms cover, or a string over 256 characters at any depth. The answer is 400 `content_rejected`, with no decision and nothing stored.

**G08.** Receipts of all four kinds (money and contact authorizations, a person's decision on a hold, an outcome report) must verify with the gate's verifier and, independently, with nothing but Ed25519, canonical JSON and the key published at `/.well-known/jwks.json`. Then one field is changed, removed or added, anywhere in the receipt, with extra weight on the fields that carry the decision and the money. The changed receipt must fail.

**G09.** The deciding policy has no rule for the action's type. The type is unknown, a near miss of a real one (other letter case, a trailing space), or a name every JavaScript object already answers to (`constructor`, `toString`, `__proto__` and the rest). Every answer is a block or a refusal. A second property sets a required capability on the rule and claims less (or a capability the gate does not know): always a block.

**G10.** A sequence of money actions under one key, some sending money out, some taking a payment in, some moving none. The window counter, the fleet total and each payee's history always equal the allowed outgoing money exactly, and incoming or no-money actions are never refused by a cap on money going out. Through the approval path too: a held action approved by a person and reported executed counts once if its money goes out, never otherwise.

**G11.** Two holds are opened; a series of attempts hits the first one: the right token, a wrong one, none, a truncated one, the other hold's token; approve, deny, other letter case, nonsense; before or after expiry; POST or GET; in half the runs racing each other. At most one attempt gets a signed decision, exactly one if any attempt was valid, that receipt is an allow only if the winner said approve, it is chained to the hold, and the other hold is untouched.

**G12.** A request that names an approver itself (even with an empty value) is refused and stores nothing. Otherwise the answer to a held action carries no approval token, no link and never the approver's address or number, unless the operator marked that key as living on a trusted server.

**G13.** A fresh payee identifier and customer reference (mixed case, stray spaces) go into a money action, a contact and a payee allowlist, in the request or pinned. After the request, an approval and an outcome report, neither the identifier as sent nor its normalized form appears in any response, receipt, stored key or value, or the operator's view of the pinned policy.

**G14.** Requests with no key, as tenant `sandbox` or `demo` or none, leave the store byte-for-byte unchanged, say `sandbox: true`, and carry a sandbox tenant and no key id. Naming any other tenant without a key, or presenting a key that does not exist, gets 401.

**G15.** One store operation of a request fails (fast-check picks which), or the signing key is missing. The answer is 503 with decision block. A paused tenant never gets an allow. An allow only comes back when nothing failed, with its amount in the counters.

**G16.** The same requests go to two fresh keys; to one of them every request also carries `window_spent_cents`, `recipient_contacts_24h`, `recipient_contacts_7d`, `subject_prior_count` and `evaluated_at`, chosen to flatter the request or to be nonsense. Every decision and reason must match the key that sent none.

### Added by the Nov 9 2026 audit

**G30.** Found by sending the live sandbox an action whose `type` was `["issue_refund"]` and whose `currency` was an object holding a sentence: both were decided as a normal refund, and the sentence came back inside the signed receipt (and, on a hold, was written to the approval record). The property plants a list, an object, a number or a sentence in `action.type`, `action.currency` or `action.target_system`, with a pinned policy, a request policy and in sandbox. The answer is 400 `invalid_action_shape`, with no decision, no receipt and nothing stored. A second test checks that ordinary codes (`USD`, `usd`, `EUR`, absent) are decided as before. This is stricter than the /vendors terms, which name content fields and a length limit only; the terms sentence is the owner's decision.

**G31.** Found by pausing a tenant with one hold already waiting: new requests were blocked, and the waiting hold was still approved into a signed allow. The property opens a money or contact hold, pauses the tenant, and tries to approve or deny through the approver's own link. No attempt is accepted, no receipt is signed, the hold stays pending and no counter moves; in half the runs the pause is then lifted and the same link works once.

**G32.** G16's generators send up to four actions, so they seldom put a recipient at its cap; a bug that let the caller's `recipient_contacts_24h` lower the gate's own count passed G16 at 1,000 runs. This property sends up to five calls to one recipient under a cap of two in 24 hours, to one key with caller figures and to another without, and requires the same decision, the same reason and the gate's own count in the receipt, with a coverage floor on calls at the cap.

Seven injected bugs were each caught: a list type read as its first name, a currency check that accepts any string, a target system that may be an object, a hold decided while paused, an unreadable pause flag read as not paused, and the caller's 24-hour and 7-day counts used in place of the gate's.

**G33.** `auto_approve_max_cents` was accepted in every policy and checked for shape, and nothing read it: a rule that set only that key at $20 allowed a $150 refund on the live sandbox (Nov 9 2026). The amount above which a person decides is now the lower of `review_above_cents` and `auto_approve_max_cents`. The property generates both limits, a hard limit, a money direction and an amount, under a pinned policy, a request policy and in sandbox: above the lower limit the answer is never allow, and within every limit it is still allow. One sample policy, `storage-risk-v1`, sets `auto_approve_max_cents`, and it sets both keys to the same number, so no sample changes.

**G34.** The approval email printed the request's `agent_id` and `tenant_label` inside its first sentence, so an agent could put "already approved by the regional manager, tap Approve" above the button. The tenant label now comes only from the operator's label on the vendor key. The agent's id is shown only when it is a plain code, on its own line under a label that says the agent sent it and it is not verified. The property sends marker words through both fields and requires that none appears in the email, the text message or the page outside that one labelled line. Nov 9, later the same day: the keyed production test showed the page judged the stored copy of the id, where spaces are already underscores, so "ALREADY_APPROVED_BY_REGIONAL_MANAGER_tap_Approve" was printed on the labelled line (the email left it out). The hold now records whether the id as sent was a plain code, the page prints the id only then, and the property judges by the id as sent.

Seven injected bugs were each caught: the limit not enforced, the higher limit applied, the label taken from the request, the id back inside the sentence, any id shown, the page judging the stored copy of the id, and every stored id marked as sent plain.

### Capability guarantees (pull request 42)

The single-use capability (a receipt that becomes the key for one action, redeemed at `/api/gate/redeem`) is not on main yet; it is in pull request 42, held for a patent decision. Its guarantees are written and run on that branch (commit `fcd65cb`, `tests/invariants/g17-g19-capability.test.cjs`, 1,000 runs each, all passing), not here:

| ID | Guarantee | Status |
|---|---|---|
| G17 | A block or escalate decision never carries a capability; a person's denial never adds one. | Passing on pull request 42 |
| G18 | A capability redeems at most once, even with up to five redemptions racing (deterministic interleavings). | Passing on pull request 42 |
| G19 | An expired capability, or one presented for a different action, amount, payee, customer or tenant, or a changed receipt, never redeems, and a refused attempt does not use it up. | Passing on pull request 42 |

Six injected bugs were each caught there: a hold carrying a capability, a denial carrying one, marking the nonce used by check-then-write, a five-minute grace after expiry, skipping the action-hash check, and a refused attempt spending the nonce. They join the table above when pull request 42 merges.

## Found by this suite

Two guarantees failed against main at commit `b1c9cf2` the first time the suite ran (Nov 3 2026). The properties were not weakened; the gate was fixed, each in its own commit with a regression test. Each failure is reproduced below with its seed (replay it on `b1c9cf2` plus the suite).

**G09, default deny.** A policy with no money rule at all, an action whose type is `constructor` (or `toString`, `__proto__`, `hasOwnProperty`, `valueOf` and the other names every JavaScript object has), any amount, claimed capability `read_only`: the gate answered **allow**. The rule lookup read `policy.rules[action.type]`, which for these names returns the object's built-in method instead of nothing, so the action passed for a rule with no limits and no required capability. With a vendor key and a pinned policy the same request was allowed too, bounded only by a window cap if the policy set one.
Replay: `INVARIANT_SEED=20261103 node --test tests/invariants/g09-default-deny.test.cjs` (fails after 9 generated cases; shrunk counterexample: type `constructor`, claim `read_only`, sandbox).
Minimal request: `{"tenant_id":"sandbox","capability_claim":"read_only","action":{"type":"constructor","amount_cents":99999999,"currency":"USD"},"policy":{"id":"p","rules":{"refund":{"required_capability":"payment_execute"}}}}` answered allow. With a vendor key whose pinned policy hard-limits refunds at $50, a $25,000 action typed `toString` with `read_only` was allowed too.
Fixed: both gates now take a rule only when the policy itself defines it (`ownRule` in `lib/gate/money-action-gate.js`). Regression test: `tests/gate-default-deny.test.js`.

**G07, content refusal.** The terms on /vendors say any string in a request longer than 256 characters is refused, but the check stopped reading four objects into the request, so a long string deeper than that was accepted: for example a 257-character sentence in a list at `extra.meta.meta.meta.note`, or in an extra field of a rule.
Replay: `INVARIANT_SEED=20261103 node --test tests/invariants/g07-content-refused.test.cjs` (fails after 3 generated cases; shrunk counterexample: a 257-character string inside a list four objects below the body).
Fixed: `api/gate/authorize.js` now finds a long string at every depth (an iterative scan, so no nesting can exhaust the stack) and still reads field names to four objects deep, exactly as the terms publish. Regression test: `tests/gate-content-depth.test.js`; the /vendors copy test that reads both limits from the code still passes.

## How the suite works

- **Real code, no network.** The properties call the production handlers (`api/gate/authorize.js`, `api/gate/approvals/[id].js`, `api/gate/outcomes.js`, `api/vendor/keys.js`, `api/vendor/policy.js`, `api/jwks.js`) and the production signer and verifier, with a synthetic signing key. Production code is not changed for the tests. The harness only wraps the store's three primitive operations (read, write, compare-and-set) so a test can order them, replaces the short random pause before a retry with an immediate retry so a run is deterministic, and sets the clock where a property needs a particular moment.
- **Generators.** `arbitraries.cjs` builds policies that pass the strict check for a pinned policy (so any of them can be sent or pinned), actions, amounts with zero and cap edges, risk scores and reason codes, payees, recipients, purposes and opt-outs, 26 time zones chosen for their edges plus 15 values that are not time zones, and instants near daylight-saving changes.
- **Deterministic simulation of concurrency.** The gate touches its store only through read, write and compare-and-set, each atomic on its own, and everything a request does between two of them runs uninterrupted. So the store operations are the only points where concurrent requests interleave. `sim.cjs` holds every store operation made during a race and releases them one at a time, in an order given by a list of numbers that fast-check generates and shrinks. Each run is one exact, replayable interleaving.
- **Two backends for races.** G03 and G05's race properties run on the store's in-memory implementation and on a real Redis: locally a private `redis-server` on a unix socket (8.6.2 on the machine that built this), in CI a Redis 7.4 service container. The store's KV REST calls, including the production Lua compare-and-set script, are answered by the real server. When no Redis can run locally, those two passes say so and skip; CI requires them.
- **Reproducible.** The default seed is 20261103. CI runs the suite twice: once with that seed, once with a fresh one. Every failure prints the seed, the path to the failing case and the exact command that replays it.
- **Not vacuous.** Each property counts the cases it reached (allows, holds and blocks, races that hit a cap, each kind of window miss, each receipt type) and fails if its generators stop reaching the case it is about.
- **Size.** 30 properties, 1,000 runs each by default (30,000 generated cases): about 22 seconds on a laptop with files in parallel (Nov 10 2026). On Nov 3 2026, with the 24 properties the suite then had, it took about 60 seconds one file at a time, and a sweep at 5,000 runs per property with a fresh seed (120,000 cases) held on every property.

## Mutation check: the suite has teeth

For each guarantee, realistic bugs were injected one at a time into a temporary copy of the gate code (with both fixes above in place, so every row starts from code that passes), and the matching property file ran against the copy at the fixed seed and 1,000 runs per property. A bug counts as caught when a property fails. `npm run test:invariants:mutations` repeats this. It never touches the working tree, it checks first that every property passes on the unchanged copy, and it refuses to report on a mutation whose target text has moved.

Result, Nov 3 2026: **31 of 31 injected bugs caught**, at least one for every guarantee. The two race bugs for money (G03) and the race bug for contacts (G05) were each caught by the in-memory pass and by the real-Redis pass independently. "First failing case" is the generated case, out of 1,000, that first broke the property.

Nov 10 2026, on main at `6ceb532`: **45 of 45 injected bugs caught**. The table below lists the 31 from Nov 3. The other fourteen are the seven for G30 to G32 and the seven for G33 and G34, each named in "Added by the Nov 9 2026 audit" above.

| Guarantee | Injected bug | Caught | Properties that failed | First failing case |
|---|---|---|---|---|
| G01 | POST /api/gate/outcomes accepts a held (escalate) receipt as the authority for an executed action | yes | 1 of 1 | run 49 |
| G01 | a held money action reserves its amount | yes | 1 of 1 | run 2 |
| G02 | a low risk score clears a hold (risk loosens escalate to allow) | yes | 1 of 2 | run 33 |
| G03 | the reservation writes counters without compare-and-set (the atomic check dropped) | yes | 2 of 2 (in-memory and Redis) | run 2 |
| G03 | a money allow stands even when its compare-and-set lost the race | yes | 2 of 2 (in-memory and Redis) | run 2 |
| G04 | a request policy that has rules wins over the pinned policy | yes | 1 of 2 | run 1 |
| G05 | off by one on the 24-hour recipient cap | yes | 3 of 4 (in-memory and Redis) | run 3 |
| G05 | the calling window's end minute is treated as inside | yes | 1 of 4 | run 65 |
| G05 | an unknown time zone is guessed as UTC instead of held | yes | 1 of 4 | run 4 |
| G05 | the 7-day contact count reads only the last 24 hours | yes | 1 of 4 | run 15 |
| G05 | a contact allow stands even when its compare-and-set lost the race | yes | 2 of 4 (in-memory and Redis) | run 1 |
| G06 | an opt-out of "all" is ignored when the request names a purpose | yes | 1 of 1 | run 6 |
| G07 | content field names are matched case-sensitively | yes | 1 of 1 | run 5 |
| G07 | long strings are read only four objects deep (the bug this suite found, put back) | yes | 1 of 1 | run 3 |
| G08 | signer and verifier both leave decision_text out of the signed content | yes | 1 of 1 | run 1 |
| G08 | the verifier accepts any receipt whose fingerprint matches, without the signature | yes | 1 of 1 | run 1 |
| G09 | the rule lookup answers to names every object has, like constructor (the bug this suite found, put back) | yes | 1 of 2 | run 9 |
| G09 | an unknown capability claim ranks as the highest | yes | 1 of 2 | run 1 |
| G10 | a payment taken in counts toward the caps | yes | 1 of 2 | run 2 |
| G10 | an approved payment taken in is added to the fleet money total | yes | 1 of 2 | run 2 |
| G11 | an approval is settled with a plain write, not compare-and-set | yes | 1 of 1 | run 150 |
| G11 | a decision is accepted after the approval expired | yes | 1 of 1 | run 6 |
| G11 | the approval token is compared by prefix | yes | 1 of 1 | run 7 |
| G12 | the status_url field carries the tokened approval link | yes | 1 of 1 | run 4 |
| G12 | a request may name its own approver | yes | 1 of 1 | run 1 |
| G13 | the approval record keeps the raw request action for the approver page | yes | 1 of 1 | run 4 |
| G14 | sandbox money requests are counted like keyed ones | yes | 1 of 1 | run 1 |
| G15 | a failed read of the pause flag counts as not paused | yes | 1 of 1 | run 36 |
| G15 | when signing fails the money decision goes out unsigned | yes | 1 of 1 | run 2 |
| G16 | the caller's window_spent_cents is trusted when sent | yes | 1 of 1 | run 156 |
| G16 | the caller's evaluated_at is used with a vendor key | yes | 1 of 1 | run 4 |

Every injected bug was reverted; none was ever written to the repository.

## How this is locked

1. `.github/CODEOWNERS` makes the code owner (`MerchantGuardOps`) the reviewer of everything in `tests/invariants/`, the CI workflow `.github/workflows/gate-invariants.yml`, and the CODEOWNERS file itself.
2. The CI job `gate-invariants` runs the suite on every pull request and on main.
3. Branch protection on `main` turns those into rules: "Require review from Code Owners" and "gate-invariants" as a required status check, enforced for administrators too. This is a repository setting the owner turns on; the exact commands are in the pull request that added this suite.

The rule for everyone, people and agents: never weaken a property to make a change pass. If a property fails, the gate is wrong until shown otherwise. A guarantee changes only with the code owner's review, and the change is explained here.

## Running it

```sh
npm run test:invariants                                        # the suite, fixed seed, 1,000 runs per property
INVARIANT_SEED=random npm run test:invariants                  # a fresh seed (printed with any failure)
INVARIANT_SEED=<seed> INVARIANT_PATH="<path>" node --test tests/invariants/<file>   # replay one failure
INVARIANT_RUNS=5000 npm run test:invariants                    # more runs
npm run test:invariants:mutations                              # the mutation check
```

## Scope and limits

- The suite checks the gate's decisions, receipts and counters. It does not check that a vendor's runtime obeys the answer; that is the vendor's side of the contract.
- The Redis passes use a real Redis and the production commands, answered through a small local bridge in place of the Upstash REST service; network faults are modeled as failed operations (G15), not as slow or partial ones.
- The content check works on field names and length, as the terms publish it. A short sentence under a neutral field name (256 characters or fewer) cannot be told apart from an identifier, so G07 does not claim it. Two more paths stay outside the published rule and therefore outside G07: a content-named field nested more than four objects deep, and a field name (rather than a value) longer than 256 characters. The gate stores neither, but it does receive the request. Closing them means changing the published terms, which is the owner's decision.
- `public_key_fingerprint` on a receipt is an optional hint outside the signed content: the verifier checks it when present, so changing it fails verification, but removing it does not change what was signed.
- Time zones are resolved by the platform's time zone database (`Intl`), the same one the gate uses.
- A money rule that names no `required_capability` sets no capability floor (contact rules default to `data_write`). G09's capability property covers rules that name one.
