Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

docs(trust): document signed hire fulfillment attestations and the reputation discount

nirholas613dcd7851b4
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 32357fd94..4778907fa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@ Public history for [three.ws](https://three.ws), newest first. New pages come fr
- **17 named commerce tools and a spending report land in the x402 MCP buyer, hosted and self-custodial**: The self-custodial x402 buyer (@three-ws/x402-mcp, npx -y @three-ws/x402-mcp) and the hosted agent wallet (https://three.ws/api/mcp-agent) both gained 17 named tools, one per fixed three.ws x402 service: weather_forecast, weather_go_no_go, carbon_now, carbon_best_window, domain_rdap_check, domain_rdap_check_bulk, research_search, research_paper, research_bibliography, book_search, book_read, news_wire_search, news_wire_poll, transit_plan, transit_delays, places_search and places_detail. Each carries a fixed input schema and states its price in its description, so a model calls it correctly far more often than it composes the equivalent raw pay_and_call(url) call. On the hosted side every named tool has a matching <name>_quote read tool that prices it without paying, and the shared tool-policy runtime (@three-ws/mcp-policy) gates payment on that exact quote (one service's quote can never unlock a different service's payment). The stdio package also gained spending_report, which totals everything pay_and_call and the named tools have paid, by merchant and by day, from a local append-only ledger (X402_MCP_LEDGER_PATH). (`/docs/mcp`) `[feature, sdk]`
- **A generated SKILL-MD 1.0 catalog of every paid HTTP route is now live at /.well-known/skill.md**: Any agent can now load one markdown file, https://three.ws/.well-known/skill.md, and get a conformant SKILL-MD 1.0 document (the x402-skill-md format) listing every priced endpoint on three.ws: method, path, price, parameters, and the Solana and Base payment rails it settles on, plus a sample 402 challenge body. The document is generated straight from the same OpenAPI catalog /openapi.json serves (api/_lib/skill-md.js reads the shared buildOpenApiDoc() builder and the real buildExactRequirements() rail logic, so the catalog and the live 402 challenge can never drift apart), and is linked from /.well-known/x402.json and llms.txt. Validated in tests/skill-md.test.js against the real upstream x402-skill-md npm validator: zero errors other than the EVM rail finding (SM005), which is expected since this is a Solana-first platform and Base settles only when a facilitator is configured. Distinct from the pre-existing https://three.ws/skill.md (no .well-known), the Agent Skills connector file for installing three.ws MCP servers; both now cross-link to the other. (`/.well-known/skill.md`) `[feature, docs]`
- **A spend call above an agent's approval threshold now pauses for the owner instead of failing**: The requires_approval verdict agent payment sessions and agent-to-agent hires can already produce now actually does something: both /api/pay/execute and /api/agents/a2a-hire create a request on the existing approval inbox the moment a call crosses the caller's approval_threshold_usd, answer with 202 and a poll link to /approvals/<id> instead of failing the call, and resume automatically the moment the owner taps Approve there, re-probing or re-running the exact same reserve-then-settle path the call would have taken inline, with no re-entry point for a double-spend. A denied request answers 403 on the next poll, an expired one answers 410, and retrying with the same idempotency key before the owner answers just re-polls instead of parking a second request. Nothing new to build on the approval page itself: it already renders any venue generically from the request's summary, amount, and risk notes, so the two new venues (payment_session_execute, a2a_hire) show up with the right Approve/Decline card for free. Covered by 21 new handler tests across create, approve, decline, expire, and the executor's own idempotent re-run. (`/approvals`) `[feature, security]`
+- **Agent-to-agent hires now carry a signed fulfillment record, and it feeds reputation and pricing**: Every settled a2a-hire (api/agents/a2a-hire.js) now writes exactly one signed attestation row: {hire_id, payment_signature, outcome, evidence_hash, signed_by}, outcome one of delivered, failed, or disputed, signed off-chain with the same platform attestation key api/_lib/attest-event.js uses for on-chain provenance memos. A client-side timeout is recorded as disputed, never inferred as delivered, since x402's verify-then-settle means the provider may already have been paid server-side. The resulting recency-weighted fulfillment rate (30-day half-life, minimum 5 attestations before it counts) is now a real input to the free Financial reputation score on every agent's Trust tab: the Settlement reliability pillar's detail line reports the rate alongside its sample size, for example '90% hire fulfillment over 12 hires', or how many hires are attested so far if the minimum has not been met yet. Providers can also opt a service into an optional x402 pricing discount for well-reputed hirers (agent_paid_services.reputation_discount_enabled, off by default): the hiring agent's reputation tier mints a short-lived, slug-scoped, signature-verified voucher, never a caller-supplied claim, so the paywall always fails closed to full price on anything unsigned, expired, or mis-scoped. (`/agents`) `[feature, security]`
- **Payment sessions gain blocked hosts, an approval threshold, and a per-rail daily cap, all with tamper-evident verdicts**: Agent payment sessions get three new governance knobs, settable at creation and editable while a session is active: blocked_hosts (a denylist checked after the allowlist, so an explicit block always wins over a broad allow, even with no allowlist set), approval_threshold_usd (a call priced above this amount now gets a distinct requires_approval verdict instead of either settling or silently failing), and per_rail_daily_usd (a rolling 24h spend cap per settlement network, reserved atomically the same way the session budget already is, closing the race a naive sum-of-past-executions check would leave open). Every governance verdict, allow or reject, now carries a policy_digest (a sha256 hash of the exact policy it was judged against) and an HMAC signature over the verdict, digest, request, and timestamp, stored with the execution: editing a session's policy after the fact changes the digest and breaks the signature on every verdict that preceded the edit, so a verdict record can be trusted even after the policy it was judged against has since moved. The dry-run simulator at /api/pay/simulate now predicts all three new rules through the exact same shared policy module the real enforcer calls, so a simulated verdict and an enforced one can never disagree; that parity is pinned by a new test running both over identical scenarios. The payments page gained matching fields in both the session creation and edit modals, with inline validation and a collapsed 'Advanced spend policy' section so the common case (budget, expiry, host allowlist) stays uncluttered. (`/docs/payment-sessions`) `[feature, security]`
- **Receipt Vault gains an Outbound tab: what your agents spent elsewhere, verified against the chain itself**: The Receipt Vault at /receipts now has two tabs. Inbound is unchanged (what three.ws billed your wallet); the new Outbound tab answers the other question: what did your agents spend at OTHER x402 merchants while running on an Agent Payment Session. Each settled Solana execution is resolved against the settlement transaction's own token-balance change the first time anyone views it (payer, payee, mint, amount, fee, slot, time), independent of whatever the merchant's response claimed, then cached so later views are free; a 'verified' badge marks a row that matched the chain, 'pending' while resolution is still in flight, and 'unverified' if the lookup failed permanently. The tab is account-session gated (the same credential /payments uses, not a wallet signature, since Payment Sessions are account-scoped, not wallet-scoped), filters by network and merchant host, and exports to CSV alongside the existing JSON receipt downloads. New endpoint: GET /api/x402/outbound-receipts. (`/receipts`) `[feature]`
diff --git a/data/changelog.json b/data/changelog.json
index fac0f1caf..e4d0849d3 100644
--- a/data/changelog.json
+++ b/data/changelog.json
@@ -1,6 +1,13 @@
{
"$comment": "Curated changelog entries for three.ws, the editorial layer of the public changelog. New PAGE launches are tracked automatically via the `added` field in data/pages.json; this file is for everything else holders care about: improvements, fixes, SDK releases, trading/payments capabilities, security work. scripts/build-page-index.mjs merges both sources into CHANGELOG.md, public/changelog.json, and public/changelog.xml. Newest first. Allowed tags: feature, improvement, fix, sdk, infra, docs, security, desktop (desktop entries become the desktop app's release notes). `link` is optional and must be a live three.ws path.",
"entries": [
+ {
+ "date": "2026-10-15",
+ "title": "Agent-to-agent hires now carry a signed fulfillment record, and it feeds reputation and pricing",
+ "summary": "Every settled a2a-hire (api/agents/a2a-hire.js) now writes exactly one signed attestation row: {hire_id, payment_signature, outcome, evidence_hash, signed_by}, outcome one of delivered, failed, or disputed, signed off-chain with the same platform attestation key api/_lib/attest-event.js uses for on-chain provenance memos. A client-side timeout is recorded as disputed, never inferred as delivered, since x402's verify-then-settle means the provider may already have been paid server-side. The resulting recency-weighted fulfillment rate (30-day half-life, minimum 5 attestations before it counts) is now a real input to the free Financial reputation score on every agent's Trust tab: the Settlement reliability pillar's detail line reports the rate alongside its sample size, for example '90% hire fulfillment over 12 hires', or how many hires are attested so far if the minimum has not been met yet. Providers can also opt a service into an optional x402 pricing discount for well-reputed hirers (agent_paid_services.reputation_discount_enabled, off by default): the hiring agent's reputation tier mints a short-lived, slug-scoped, signature-verified voucher, never a caller-supplied claim, so the paywall always fails closed to full price on anything unsigned, expired, or mis-scoped.",
+ "tags": ["feature", "security"],
+ "link": "/agents"
+ },
{
"date": "2026-10-15",
"title": "Receipt Vault gains an Outbound tab: what your agents spent elsewhere, verified against the chain itself",
diff --git a/docs/ALL.md b/docs/ALL.md
index d13a3ee1d..a468e85a1 100644
--- a/docs/ALL.md
+++ b/docs/ALL.md
@@ -1,7 +1,7 @@
<!-- GENERATED by scripts/combine-docs.mjs — do not edit by hand. Edit the source files under docs/ and re-run. -->
# three.ws — Combined Documentation
-> Single-file snapshot of every document under [`docs/`](.). Generated 2026-10-14 from **882 files** (~13453 KB).
+> Single-file snapshot of every document under [`docs/`](.). Generated 2026-10-15 from **882 files** (~13480 KB).
> The individual source files remain the canonical, editable copies — this file is a read-only aggregate.
## Table of contents
@@ -10257,6 +10257,14 @@ An agent's profile shows the receipts behind its score: every completed hire it
**Why it matters:** Every star traces to a transaction hash — reputation you can click through and verify, line by line.
+## Signed fulfillment attestations: delivered, failed, or disputed, never guessed
+
+Every settled a2a-hire writes exactly one signed attestation row recording what actually happened: delivered, failed, or disputed. It is signed off-chain with the same platform attestation key three.ws uses for on-chain provenance memos, so it can't be forged by either the hirer or the provider. A client-side timeout is recorded as disputed, never inferred as delivered: three.ws's x402 payments verify-then-settle, so the provider may already have been paid server-side by the time a timeout reaches the hirer, and guessing the wrong way would reward an agent for a call that actually failed.
+
+**How it works:** The resulting recency-weighted fulfillment rate (newer attestations count more, 30-day half-life) becomes a real input to the free Financial reputation score once an agent has at least 5 attestations as a provider; below that minimum the rate stays hidden rather than scoring an unproven agent on too little data. The Settlement reliability pillar on every agent's Trust tab states the rate alongside its sample size, for example "90% hire fulfillment over 12 hires." A provider can also opt a priced service into an optional reputation discount for well-reputed hirers: the hiring agent's tier mints a short-lived, slug-scoped, signature-verified voucher at hire time, and the paywall only ever trusts that signature, never a caller-supplied claim, so it fails closed to full price on anything unsigned, expired, or mis-scoped.
+
+**Why it matters:** A star rating is an opinion; a signed attestation is a verifiable record the platform itself stands behind, and it is the one reputation input a dishonest hirer or provider cannot inflate by leaving themselves five stars.
+
## Validation attestations — verified fact, not just opinion
Reputation captures what people think; validation captures what was checked. Validators attest on-chain that an agent passed a concrete technical test (on three.ws, that its 3D model passes glTF schema validation), and the same pass/fail attestations exist on Solana as signed memos. Signed validator reports also travel inside the agent's manifest bundle.
@@ -13506,6 +13514,7 @@ The agent's private key lives encrypted on the server and never touches the brow
- Client-side validation: positive amounts only, amount cannot exceed the available balance, destination must resolve
- Two-step flow: a review/confirm screen summarizing asset, amount, destination, and network before anything is submitted
- Live allowlist badge on the confirm screen: '✓ allowlisted' or '⚠ not on allowlist — this will be rejected' before you even press Confirm
+- Sweeper-bot warning on the confirm screen: a read-only check of the destination's recent on-chain history flags a wallet that is repeatedly drained within seconds of receiving funds, with a blocking confirm you must explicitly accept before the send goes through
- Irreversibility warning on every confirmation: crypto transfers are final
- Risk-acknowledgment gate before any mainnet withdrawal (with a graceful fallback prompt if the dialog module fails to load); devnet skips it
- Single-use CSRF token on every state-changing request — the server burns each token on use
@@ -13533,7 +13542,7 @@ The agent's private key lives encrypted on the server and never touches the brow
## Guardrails & safety
-Owner-only end to end: every endpoint verifies the signed-in user owns the agent. Withdrawals are capped at 5 per day per user with an additional per-IP burst guard. Every state-changing request requires a single-use CSRF token, and mainnet withdrawals require an explicit risk acknowledgment. The server enforces the shared spend policy before signing: withdraw allowlist (if set, funds can only go to approved addresses), per-transaction and rolling 24-hour USD ceilings, the owner's plain-English safety rules enforced deterministically, and a behavioral anomaly guard that can auto-freeze the wallet. The freeze switch halts all autonomous spending but deliberately never blocks the owner's withdrawals — a freeze can never trap funds. Destinations must be valid, on-curve addresses and cannot be the wallet itself. SOL sweeps always reserve rent plus fees so the account survives. Idempotency keys make retries safe against double-sends, ambiguous confirmations return a pending state with an explorer link instead of guessing, and every withdrawal, key decryption, limit change, and policy block lands in an owner-visible audit ledger.
+Owner-only end to end: every endpoint verifies the signed-in user owns the agent. Withdrawals are capped at 5 per day per user with an additional per-IP burst guard. Every state-changing request requires a single-use CSRF token, and mainnet withdrawals require an explicit risk acknowledgment. The server enforces the shared spend policy before signing: withdraw allowlist (if set, funds can only go to approved addresses), per-transaction and rolling 24-hour USD ceilings, the owner's plain-English safety rules enforced deterministically, and a behavioral anomaly guard that can auto-freeze the wallet. The freeze switch halts all autonomous spending but deliberately never blocks the owner's withdrawals: a freeze can never trap funds. Destinations must be valid, on-curve addresses and cannot be the wallet itself. The server also reads the destination's recent transaction history for the sweeper-bot pattern (incoming SOL drained again within seconds, repeated); a flagged address blocks the send with an explicit confirm the owner must accept before it is retried. SOL sweeps always reserve rent plus fees so the account survives. Idempotency keys make retries safe against double-sends, ambiguous confirmations return a pending state with an explorer link instead of guessing, and every withdrawal, key decryption, limit change, and policy block lands in an owner-visible audit ledger.
## Screenshot-worthy (shot list)
@@ -16783,6 +16792,13 @@ spend rule. See [three.ws for Grok](grok.md#a-skill-file-for-grok). Its prose li
in [`data/grok-skill-md.template.md`](../data/grok-skill-md.template.md) and the same
build renders it to [`public/grok-skill.md`](../public/grok-skill.md).
+### Not the x402 paid-route catalog: `https://three.ws/.well-known/skill.md`
+
+A different, unrelated document despite the similar name: a
+[SKILL-MD 1.0](https://github.com/nirholas/x402-skill-md) catalog of every priced
+HTTP endpoint on three.ws (price, parameters, Solana/Base payment rails), generated
+from `/openapi.json`. See [x402 Paid Endpoints](x402-endpoints.md#agent-readable-catalog-skillmd).
+
Both templates draw every shared fact from
[`scripts/lib/skill-md-facts.mjs`](../scripts/lib/skill-md-facts.mjs): `{{FREE_MCP}}`
and the other server URLs come from `public/.well-known/mcp.json`, the free limits
@@ -18685,7 +18701,7 @@ a pass.
# Agent wallet control API
-Every three.ws agent owns one custodial **Solana** wallet. Seven owner-only HTTP surfaces hang off it, and this is their developer reference: exact routes, exact request and response JSON, exact error codes, and a working curl call for each.
+Every three.ws agent owns one custodial **Solana** wallet. Eight owner-only HTTP surfaces hang off it, and this is their developer reference: exact routes, exact request and response JSON, exact error codes, and a working curl call for each.
This document is the API reference the surrounding docs deliberately leave out. Read those first for the "why":
@@ -18697,7 +18713,7 @@ This document is the API reference the surrounding docs deliberately leave out.
## Orientation
-All seven surfaces address the same custodial Solana keypair, obey the same owner gate, and are clamped by the same spend policy. None of them can widen authority: each one either reads the wallet, or narrows and schedules what the wallet is already allowed to do.
+All eight surfaces address the same custodial Solana keypair, obey the same owner gate, and are clamped by the same spend policy. None of them can widen authority: each one either reads the wallet, or narrows and schedules what the wallet is already allowed to do.
| Surface | Route root | What it controls |
|---|---|---|
@@ -18708,6 +18724,7 @@ All seven surfaces address the same custodial Solana keypair, obey the same owne
| Portfolio | `/api/agents/:id/portfolio` | FIFO cost basis, realized and unrealized P&L by source, live risk metrics |
| Recovery | `/api/agents/:id/recovery` | Guardians, approval threshold, dead-man check-in, inheritance |
| Solana guard | `/api/agents/:id/solana/guard` | The behavioral anomaly baseline, its sensitivity, and freeze adjudication |
+| Spend delegation | `/api/agents/:id/solana/delegation` | The owner-signed, epoch-bounded spend cap verified against realized ledger spend |
The shared model, in one paragraph. A caller is resolved to a user id from either a session cookie or a bearer token. That user must own the agent, or the surface refuses (recovery is the one exception: guardians and the beneficiary get a scoped view). Every mutation is CSRF-gated for cookie callers. Anything that can move funds runs through the shared spend guards in [`api/_lib/agent-trade-guards.js`](../api/_lib/agent-trade-guards.js), so the wallet-wide policy (`per_tx_usd`, `daily_usd`, `per_counterparty_daily_usd`, `withdraw_allowlist` (the [destination whitelist](#sec-243), edited through `/api/wallet-whitelist`), `frozen`, `require_capabilities`) is enforced at the signing boundary, not per feature. A scheduled order, an armed intent, an autopilot rule, and an autonomous agent-to-agent payment are therefore all subject to the same ceilings and the same freeze as a manual trade. That enforcement fails closed on its inputs: a caller that hands the guard neither a pre-read policy nor the agent's meta gets the agent's real policy read from its row, and a spend for an agent that no longer exists is refused rather than defaulted to an unrestricted wallet. See [autonomous agent-to-agent payments](#sec-008) for the policy fields, the kill switch, and the receipts they leave behind.
@@ -19892,6 +19909,49 @@ curl -s -X POST "https://three.ws/api/agents/$AGENT_ID/solana/guard" \
-d '{"action":"approve","event_id":"4417"}'
```
+## Signed spend delegation: a portable, offline-verifiable cap
+
+Source: [`api/_lib/agent-spend-delegation.js`](../api/_lib/agent-spend-delegation.js), dispatched from [`api/agents/solana-wallet.js`](../api/agents/solana-wallet.js). Canonical format, message builder, and the zero-dependency verify/cap math: [`packages/agent-guards/src/delegation.js`](../packages/agent-guards/src/delegation.js) (full spec in that package's [README](../packages/agent-guards/README.md#spec-signed-spend-delegation)). Owner-facing UI: the Delegation tab in the agent wallet hub ([`src/agent-wallet-hub/tabs/delegation.js`](../src/agent-wallet-hub/tabs/delegation.js)).
+
+A delegation is a statement the owner signs with their own linked Solana wallet, never a transaction: *"agent X may move at most CAP lamports per EPOCH_SECONDS, until NOT_AFTER."* Unlike every other control on this page, it is not three.ws-specific: the signed envelope is plain text, and `verifyDelegationSignature` is a ~100-line, dependency-free function any counterparty can run themselves to confirm the authorization without trusting three.ws's say-so. three.ws also enforces the same cap server-side, on every preflight through [`POST /api/agent/guard`](#preflight-guard-enforcement), measured from the agent wallet's REALIZED spend in `agent_custody_events` rather than the agent's own claim about what an action will cost, so an exact-output trade that ends up costing more than advertised still cannot slip past the ceiling.
+
+| Method | Route | Purpose |
+|---|---|---|
+| `GET` | `/solana/delegation` | The current delegation on file (any status), or `null` |
+| `POST` | `/solana/delegation` | Verify and store a delegation the owner already signed in their wallet |
+
+Both are owner-gated and rate-limited; `POST` is CSRF-gated. This route is a convenience layer for the owner-facing UI, not the security boundary: the real authorization check is the Ed25519 signature, which is why the lower-level preflight endpoint below can accept the same envelope anonymously.
+
+### GET /solana/delegation
+
+```json
+{ "data": { "delegation": {
+ "id": "…", "agent_id": "…", "owner_wallet": "7Xy…",
+ "cap_lamports_per_epoch": "500000000", "epoch_seconds": 86400,
+ "not_after": "2026-11-13T00:00:00.000Z", "nonce": "a1b2c3…",
+ "status": "active", "created_at": "2026-10-14T18:00:00.000Z"
+} } }
+```
+
+`delegation` is `null` when none is on file. Note that a time-expired row is still returned (its `not_after` is simply in the past) rather than disappearing: a delegation that lapsed is a fact the owner should see, not silence.
+
+### POST /solana/delegation
+
+Body: `{ "delegation": { "agent", "owner", "cap_lamports_per_epoch", "epoch_seconds", "not_after", "nonce" }, "delegationSignature": "<base58 or base64>" }`. Every delegation field is carried as a decimal string; see the package README for the exact canonical message those six fields serialize to before signing.
+
+```bash
+curl -s -X POST "https://three.ws/api/agents/$AGENT_ID/solana/delegation" \
+ -H "authorization: Bearer $THREE_WS_TOKEN" \
+ -H 'content-type: application/json' \
+ -d '{"delegation":{"agent":"'"$AGENT_ID"'","owner":"7Xy…","cap_lamports_per_epoch":"500000000","epoch_seconds":"86400","not_after":"1794700800","nonce":"a1b2c3d4"},"delegationSignature":"base64sig…"}'
+```
+
+Rejections are specific, each a `DelegationError` code: `invalid_delegation` (malformed field), `expired_delegation` (`not_after` already in the past), `agent_not_found` (no owner wallet linked to this agent), `wrong_signer` (the signature does not verify against the agent's linked owner wallet), `replayed_nonce` (this exact `agent_id` + `nonce` pair was already registered, whatever its current status). A nonce is permanently retired on first use: a captured signed envelope can never be resubmitted to reset the epoch counter or re-extend an authorization past what was actually signed.
+
+### Preflight guard enforcement
+
+[`POST /api/agent/guard`](../api/agent/guard.js) is the one endpoint that actually enforces a delegation's cap. It accepts the same `{ delegation, delegationSignature }` pair inline (registering or re-registering before evaluating `calls`) and, for every proposed call, resolves the call's lamport cost and rejects with `blockedBy: "spend_delegation"` and `code: "DELEGATION_CAP_EXCEEDED"` or `"DELEGATION_EXPIRED"` when the active delegation would be breached. The delegation layer only ever *tightens* an `allow` into a `block`; if the guard's seven existing layers already blocked the call for another reason, the delegation check never runs or overrides it.
+
## Related
- [Agent wallets](#sec-077) for the wallet itself: creation, key custody, and the five spend paths.
@@ -19965,7 +20025,7 @@ Two asymmetries are deliberate:
Coin-launch and bonding-curve activity carries an additional SOL-denominated policy (`max_sol_per_tx`, `daily_sol_cap`, an optional `allowed_mints` allowlist). A freshly provisioned agent that has never been configured defaults to **1 SOL per transaction and 5 SOL per rolling day**, so a stolen session token cannot drain it.
-On top of the numeric caps sit two additive layers, each of which can only ever *narrow* a spend, never widen it: [natural-language spend rules](#sec-309) that an LLM authors and deterministic code enforces, and a behavioral anomaly guard that freezes the wallet when a spend doesn't look like the agent's normal behavior.
+On top of the numeric caps sit three additive layers, each of which can only ever *narrow* a spend, never widen it: [natural-language spend rules](#sec-309) that an LLM authors and deterministic code enforces, a behavioral anomaly guard that freezes the wallet when a spend doesn't look like the agent's normal behavior, and an owner-signed, epoch-bounded [spend delegation](agent-wallet-api.md#signed-spend-delegation-a-portable-offline-verifiable-cap) that any outside counterparty can verify offline, enforced against the wallet's realized ledger spend rather than a self-reported amount.
### The audit trail
@@ -19973,7 +20033,7 @@ Every spend writes a row to the custody event ledger — amount, USD value, dest
## Where owners manage it
-The **Agent Wallet Hub** lives at `/agent/:id/wallet`. Owners see all 23 sections; a visitor to a public agent page sees a read-only view: Balance, Deposit, Trust, Trade, and Pulse. Everything a visitor sees is public on-chain data, so the balance a visitor reads is the same live figure the owner reads. The transaction feed is the exception: it is owner-only server-side, so the visitor's Balance tab says so and links to the block explorer instead. A network selector switches every read and write between mainnet and devnet.
+The **Agent Wallet Hub** lives at `/agent/:id/wallet`. Owners see all 26 sections; a visitor to a public agent page sees a read-only view: Balance, Deposit, Trust, Trade, and Pulse. Everything a visitor sees is public on-chain data, so the balance a visitor reads is the same live figure the owner reads. The transaction feed is the exception: it is owner-only server-side, so the visitor's Balance tab says so and links to the block explorer instead. A network selector switches every read and write between mainnet and devnet.
`/agent-wallet` is the same hub reached without naming an agent. It resolves the signed-in owner's agents: one agent opens its hub directly, several render a picker, none offers a route to create the first one, and a signed-out visitor is asked to sign in.
@@ -19986,6 +20046,7 @@ Key endpoints:
- `GET`/`PUT /api/agents/:id/solana/limits`: read and set the spend policy
- `POST /api/agents/:id/solana/withdraw`: sweep an asset out
- `GET /api/agents/:id/solana/guard` — anomaly guard state and flagged activity
+- `GET`/`POST /api/agents/:id/solana/delegation`: read, or verify-and-store, an owner-signed [spend delegation](agent-wallet-api.md#signed-spend-delegation-a-portable-offline-verifiable-cap)
Full request/response shapes are in the [REST API reference](#sec-125).
@@ -38024,10 +38085,16 @@ A source registers an executor in the `EXECUTORS` map in
`executor(row)` receives the stored row, executes only `row.payload`, and
returns `{ status: 'ok'|'error'|'paused'|'skipped', signature?, note?, usd? }`.
Registered sources include `wallet_intent` (agent transfers and swaps from
-wallet intents) and `mail_rule` (an [agent mail](#sec-058) rule in
+wallet intents), `mail_rule` (an [agent mail](#sec-058) rule in
`approve` mode: approving starts a read-only, zero-budget run on the email that
matched, and its table names the agent, the email and the instruction with
-`Spend: None`). Then call `createApprovalRequest()` where the source hits
+`Spend: None`), `payment_session_execute` (an agent payment session call
+priced above its `approval_threshold_usd`: [api/pay/execute.js](../api/pay/execute.js)
+parks the call instead of failing it, and the caller polls the same endpoint
+with `GET` until it resumes), and `a2a_hire` (an agent-to-agent hire priced
+above the hiring agent's `approval_threshold_usd`: [api/agents/a2a-hire.js](../api/agents/a2a-hire.js)
+parks the hire and the caller's retry with the same idempotency key re-polls
+it). Then call `createApprovalRequest()` where the source hits
its step-up gate, with an idempotency key derived from the action. Engines
that execute inline (an auto-approved request) call `runApproved(row, run)`,
which provides the same once-only and integrity guarantees.
@@ -66735,6 +66802,7 @@ is documented in its section below and machine-readable in the OpenAPI doc.
| [`/api/crypto/bonding`](https://three.ws/api/crypto/bonding) | `GET` | Where a pump.fun token sits on its bonding curve — % to graduation, SOL in the curve, and whether it has migrated to an AMM. |
| [`/api/crypto/holders`](https://three.ws/api/crypto/holders) | `GET` | Holder distribution for a Solana token — top wallets with % of supply, cumulative top-10 share, and a documented concentration verdict. |
| [`/api/crypto/launches`](https://three.ws/api/crypto/launches) | `GET` | The freshest pump.fun launches, newest first — age, market cap, bonding-curve progress, dev wallet — with `minMarketCap` / `maxAgeMin` filters built for polling agents. |
+| [`/api/crypto/linkage`](https://three.ws/api/crypto/linkage) | `GET` | Whether 2-10 Solana wallets share a controller - pairwise 0-100 same-controller scores with evidence (shared fee payer, first-funder, token-account control, direct transfer, funding burst). |
| [`/api/crypto/portfolio`](https://three.ws/api/crypto/portfolio) | `GET` | A wallet read shaped for a portfolio view - stable/major/other split, top-asset allocation, per-token 24h change, and an aggregate 24h move that states its own coverage. |
| [`/api/crypto/security`](https://three.ws/api/crypto/security) | `GET` | Pre-trade rug check for a Solana token — authority, concentration, liquidity, mutability, and LP-custody facts composed into a deterministic riskLevel. |
| [`/api/crypto/symbol`](https://three.ws/api/crypto/symbol) | `GET` · `POST` | Whether up to 20 candidate tickers are taken — exact and fuzzy (look-alike) collisions across live registries. |
@@ -67739,6 +67807,88 @@ curl -s "https://three.ws/api/crypto/airdrops?address=<wallet>" \
---
+## `GET /api/crypto/linkage` - Wallet linkage (same-controller scoring)
+
+**Use-case.** A *sniper or copy-trade agent* vetting a coin's early buyers
+needs to know whether they are independent actors or the creator's own alts
+dressed up as organic demand, and a *copy-trade follower* needs to know a
+leader isn't secretly the creator of the coin they're "signaling". One call
+answers both: pairwise 0-100 same-controller scores, with evidence, across
+2-10 Solana addresses.
+
+### Request
+
+| Param | Type | Default | Notes |
+|-------------|--------|----------|-------|
+| `addresses` | string | required | Comma-separated list of 2 to 10 Solana addresses to cross-check. |
+
+### Response
+
+```json
+{
+ "addresses": ["FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump", "11111111111111111111111111111111"],
+ "pairs": [
+ {
+ "a": "FeMbDoX7R1Psc4GEcvJdsbNbZA3bfztcyDCatJVJpump",
+ "b": "11111111111111111111111111111111",
+ "score": 0,
+ "band": "none",
+ "topSignal": null,
+ "signals": [],
+ "evidence": []
+ }
+ ],
+ "complete": true,
+ "ts": "2026-10-14T20:00:00.000Z"
+}
+```
+
+- **`score`/`band`** - a 0-100 noisy-OR combination of six signals (shared fee
+ payer, one address funding the other, both sharing a first funder, SPL
+ token-account control, direct transfers, a shared funder sending similar
+ amounts in a short window), bucketed into `none` / `weak` / `moderate` /
+ `strong` / `confirmed`.
+- **`topSignal`** - the single highest-weight signal that fired for the pair,
+ or `null` when no signal fired.
+- **`evidence`** - the signature or account that triggered each contributing
+ signal, so a caller can verify the claim on-chain rather than trust the score
+ blind.
+- **`complete: false`** - at least one address's history walk hit its time or
+ request budget before finishing. The score is still real, just possibly
+ based on partial history.
+
+### Sources
+
+Solana RPC only (this deployment's own failover chain, keyless): account info,
+parsed transaction history, and signature lists for each address. A known
+service/exchange wallet that funds many unrelated addresses is excluded from
+the shared-funder signals at runtime (`WALLET_LINKAGE_EXCLUDED_ACCOUNTS` /
+`WALLET_LINKAGE_EXCLUSIONS_PATH`) rather than evidence of a link.
+
+### States
+
+- **2-10 valid Solana addresses** -> `200` with scored pairs.
+- **Missing `addresses`** -> `400 missing_addresses`.
+- **Fewer than 2 or more than 10 addresses** -> `400 invalid_address_count`.
+- **An EVM address mixed in** -> `400 unsupported_chain` (Solana only; this
+ endpoint is Solana-first by design, not an EVM gap).
+- **A malformed address** -> `400 invalid_address`.
+- **Solana RPC unreachable** -> `503 upstream_unavailable` with
+ `Retry-After: 15`, or a `200` stale envelope if a cached result exists.
+- **Rate-limited** -> `429`.
+
+### Examples
+
+```bash
+# Are these two wallets the same controller?
+curl -s "https://three.ws/api/crypto/linkage?addresses=<walletA>,<walletB>"
+
+# Highest-scoring pair only
+curl -s "https://three.ws/api/crypto/linkage?addresses=<a>,<b>,<c>" | jq '.pairs | max_by(.score)'
+```
+
+---
+
## Related
- [Market Data API](/docs/market-data-api) - the paid x402 twin: coin prices, DeFi TVL, yields, gas, and the per-datapoint fabric
@@ -105035,8 +105185,15 @@ transactions:
1. Resolve the signed-in user's primary agent wallet (`agent_identities`, Solana).
2. Recover the keypair (`recoverSolanaAgentKeypair`) and build an `x402Client`
- with `ExactSvmScheme`.
-3. Install the platform spending cap (`enforceCap → commit / rollback`).
+ with `registerExactSvmScheme`, which registers both x402 wire formats on
+ the Solana scheme: v2 (`solana:*`, CAIP-2) and v1 (`solana`,
+ `solana-devnet`, `solana-testnet`), the format most of the open x402
+ bazaar, including the owner's `x402-suite`, still speaks. When a seller
+ advertises both, v2 is always preferred; settlement receipts come back in
+ the same shape (`success`, `transaction`, `network`, `payer`) either way.
+3. Install the platform spending cap (`enforceCap → commit / rollback`),
+ which reads either `amount` (v2) or `maxAmountRequired` (v1) so both
+ protocol versions are capped the same way.
4. `wrapAxiosWithPayment` runs the 402 → sign → retry → settle dance.
Per-call/hour/day caps come from `X402_MAX_PER_CALL_ATOMIC`,
@@ -108048,6 +108205,45 @@ winning close actually pays across eight price moves after Papertrade's deadband
win fee. `papertrade_account` values any wallet's open positions at the live mid. The same data is on
`GET /api/papertrade`. Full guide: [Papertrade](#sec-478).
+### Named commerce tools: pay a fixed three.ws service
+
+Seventeen named tools, each wired to one fixed three.ws x402 endpoint, exist on two servers so the
+same tool names, prices and schemas are available whether an agent talks to the self-custodial
+stdio package or the hosted agent wallet:
+
+- **Hosted** (`https://three.ws/api/mcp-agent`): pays from the signed-in user's own three.ws agent
+ wallet, the same rail `pay_and_call` uses. Each service gets a `<name>_quote` read tool (prices it,
+ never pays) and a `<name>` financial tool, gated by the shared policy runtime on that service's own
+ `quote_id` plus `confirm_payment: true`. A quote from one service can never unlock a different
+ service's payment: every financial tool's preview tool name is unique to it.
+- **Stdio** (`npx -y @three-ws/x402-mcp`): pays with the local `SOLANA_SECRET_KEY` (or a Payment
+ Session token), the same settlement modes as that package's `pay_and_call`. See
+ [its README](../packages/x402-mcp/README.md#tools) for the full tool-to-endpoint table.
+
+| Tool | Price | What it pays for |
+|------|-------|-------------------|
+| `weather_forecast` | $0.001 | 24h hourly forecast at a lat/lon (Open-Meteo, NWS fallback) |
+| `weather_go_no_go` | $0.002 | go/caution/no-go verdict for an activity from the next 6h forecast |
+| `carbon_now` | $0.001 | current UK grid carbon intensity, national or by postcode |
+| `carbon_best_window` | $0.002 | lowest-carbon window in the next 48h |
+| `domain_rdap_check` | $0.001 | one domain's live RDAP registration status |
+| `domain_rdap_check_bulk` | $0.005 | up to 50 domains' RDAP status in one call |
+| `research_search` | $0.002 | merged arXiv + Crossref + Semantic Scholar paper search |
+| `research_paper` | $0.003 | one paper's metadata plus its two-sided citation graph |
+| `research_bibliography` | $0.005 | BibTeX / APA 7 for up to 25 DOIs |
+| `book_search` | $0.001 | OpenLibrary edition search, flagged for a Gutenberg full text |
+| `book_read` | $0.01 | a public-domain book's complete text, split into chapters |
+| `news_wire_search` | $0.003 | GDELT worldwide news search with a coverage timeline |
+| `news_wire_poll` | $0.002 | GDELT articles since a cursor, for an ongoing monitor loop |
+| `transit_plan` | $0.002 | an MBTA trip plan between two stops, with realtime overlays |
+| `transit_delays` | $0.001 | realtime vs. scheduled MBTA arrivals at one stop |
+| `places_search` | $0.002 | OpenStreetMap points of interest near a coordinate |
+| `places_detail` | $0.002 | one place's full OpenStreetMap record |
+
+`spending_report` (stdio package only, read-only) totals everything paid through that key, by
+merchant and by day, from the package's local append-only ledger
+(`X402_MCP_LEDGER_PATH`, default `~/.three-ws/x402-mcp-ledger.jsonl`).
+
---
## Resources
@@ -108244,7 +108440,23 @@ On `mcp`:
2. `pumpfun_recent_graduations`: what recently graduated launches have in common.
3. `read_resource` on `three://agents/{agentId}/wallet`: enough SOL for the launch fee?
4. Show the name, symbol, description, image, launching wallet and cost, and wait for a yes.
-5. **Spends money.** Launching from MCP is not enabled yet: the user reviews and signs the launch on [/launch](https://three.ws/launch). Then `read_resource` on `three://launches` to confirm it landed.
+5. `pumpfun_prepare_launch` with the agreed `name`, `symbol`, `description`, `image_url`, and optionally `initial_buy_sol` and `agent_id`. It validates every field the same way the launch page does, fetches and type/size-checks the image, and returns a pre-filled `/launch` URL plus a plain-English summary. It never launches anything itself: `requires_human_signature` is always `true` in the response.
+
+ ```json
+ {
+ "name": "pumpfun_prepare_launch",
+ "arguments": {
+ "name": "Agent Nova",
+ "symbol": "NOVA",
+ "description": "A trading agent with a coin.",
+ "image_url": "https://cdn.example.com/nova.png",
+ "initial_buy_sol": 0.5,
+ "agent_id": "agent-123"
+ }
+ }
+ ```
+
+6. **Spends money.** The user opens the `launch_url` from the response, reviews every pre-filled field on [/launch](https://three.ws/launch) (shown there under an "prepared from your assistant" banner), and signs the transaction in their own wallet. Then `read_resource` on `three://launches` to confirm it landed.
### Hire an agent for a task (`hire-agent`)
@@ -113439,7 +113651,7 @@ All of it lives in one file, [`api/_lib/native-launch/config.js`](../api/_lib/na
| Metadata authority | Immutable at launch |
| Starting market cap | 4,000,000 $THREE |
| Graduation market cap | 60,000,000 $THREE (about 12.3M $THREE raised on the curve) |
-| Trading fee | 1%, taken in $THREE, plus a volatility-scaled dynamic fee during spikes |
+| Trading fee | 1% steady-state, taken in $THREE, plus a volatility-scaled dynamic fee during spikes. Decays down from 50% over a pool's first 100 slots (below) |
| Trading fee split | 50% coin creator / 50% three.ws |
| Migration fee | 1% of the raised $THREE, split 50/50 |
| Graduates into | A Meteora DAMM v2 pool against $THREE |
@@ -113457,6 +113669,14 @@ The curve deliberately mirrors the shape traders already recognise from pump.fun
The DBC program takes the quote mint's token program as an ordinary account, so a Token-2022 quote is supported on-chain. SDK 1.5.x nevertheless hardcodes the legacy SPL Token program into `token_quote_program` when it builds a pool-initialize instruction, and with a Token-2022 quote the instruction fails with `IncorrectProgramId` as soon as the program creates the quote vault. `withQuoteTokenProgram` in [`dbc.js`](../api/_lib/native-launch/dbc.js) rewrites that one account, located by its position in the program's own IDL. Swaps are unaffected: the SDK reads the token program from the config for those. Remove the patch when the SDK is fixed upstream.
+### Anti-snipe: a decaying fee instead of a flat one
+
+Every pool opens at a 50% trading fee (`antiSnipeStartFeeBps`), which decays exponentially down to the steady-state 1% (`antiSnipeEndFeeBps`) over the pool's first 100 slots (`antiSnipeDecaySlots`, about 40 seconds at Solana's ~400ms/slot), stepped through 25 discrete periods (`antiSnipeDecayPeriods`). A bot buying in the pool's first block pays close to half its $THREE in fees; an organic buyer a minute later pays the normal 1%. The coin's own creator is exempt: their bundled first buy (the same transaction as pool creation) always pays the lane's minimum fee via `enableFirstSwapWithMinFee`, since it is the creator funding their own launch, not a snipe.
+
+This mirrors the owner's EVM `anti-snipe-ramp` hook concept, but it is built entirely on the DBC program's own fee scheduler rather than a new contract: `fee.baseFeeParams` in [`config.js`](../api/_lib/native-launch/config.js) sets `BaseFeeMode.FeeSchedulerExponential` with a starting and ending fee, a period count, and a duration in slots. Exponential was chosen over linear because it front-loads the drop (steepest right after activation, where snipers are, instead of a constant slope), and over the SDK's `RateLimiter` mode because that mode is deprecated in this SDK version and throws for any new config.
+
+One honest difference from the EVM hook: on an EVM AMM, an anti-snipe ramp's excess fee typically accrues to the pool's liquidity providers. On this lane, all trading fees (ramped or steady-state) flow through the same 50/50 creator/three.ws split that every other trade uses, never to LPs, because DBC pools have no third-party LPs before graduation. The anti-snipe premium a sniper pays is extra revenue for the coin's creator and the platform, not a yield booster for outside liquidity.
+
### Why `leftover: 1`
The DBC program requires that the tokens on the curve, the tokens reserved for migration, and the leftover reconcile *exactly* against the fixed supply. A leftover of `0` fails that check on-chain with `InvalidTokenSupply`. One base unit of dust satisfies it. This was found by simulating the real `create_config` instruction against devnet, and it is pinned by a test so nobody "cleans it up" later.
@@ -123464,11 +123684,11 @@ a demo far more often than to a proposal.
| WordPress, Framer and Webflow embeds | Agent, order 094 | Owner: directory submissions (938) |
| Home Assistant HACS package | Agent, order 095 | Owner: the HACS default pull request and its CI exception (938) |
-Engine bridges (Unity, Unreal, Godot) and store publishing (Fab, Unity Asset Store, itch) are
-already planned in best3d orders [072](../prompts/finish/072-best3d-06-engine-bridges.md) and
+Engine bridges (Unity, Unreal, Godot) shipped; see [the engine bridges doc](#sec-264).
+Store publishing (Fab, Unity Asset Store, itch) is still planned in best3d order
[935](../prompts/finish/935-best3d-08-engine-store-publishing.md). The orphaned avatar
-campaign is [934](../prompts/finish/934-best3d-07-orphaned-avatar-campaign.md), with the
-three-vrm work and VRM 0.x export in [075](../prompts/finish/075-best3d-09-three-vrm.md).
+campaign is [934](../prompts/finish/934-best3d-07-orphaned-avatar-campaign.md); the three-vrm
+work and VRM 0.x export shipped and is now live, see [the avatar engines doc](#sec-146).
This plan does not duplicate them.
### Wave 3: commercial partners (weeks 4 to 10)
@@ -124333,7 +124553,7 @@ These lose value by waiting. Everything else on this page can be worked in wave
| Opening | Why it is closing | Our asset | Where it is worked |
|---|---|---|---|
| **Tripo's inbound** | An inbound conversation cools in days | [tripo.md](#sec-493): brief, asks, offers, reply draft | Wave 0 of the [outreach plan](#sec-487) |
-| **Ready Player Me users** | The service shut down on 2026-01-31 and both its hostnames are dead in DNS today. Two competitors are already publishing "alternative to Ready Player Me" pages for these users | `/import/rpm` exists and the Wolf3D skeleton already animates, but the page is marked `noindex` | Owner-gated order [934](../prompts/finish/934-best3d-07-orphaned-avatar-campaign.md) and order [075](../prompts/finish/075-best3d-09-three-vrm.md) |
+| **Ready Player Me users** | The service shut down on 2026-01-31 and both its hostnames are dead in DNS today. Two competitors are already publishing "alternative to Ready Player Me" pages for these users | `/import/rpm` exists and the Wolf3D skeleton already animates, but the page is marked `noindex` | Owner-gated order [934](../prompts/finish/934-best3d-07-orphaned-avatar-campaign.md); the three-vrm work this depends on already shipped, see [the avatar engines doc](#sec-146) |
| **Stranded motion-capture users** | Meshcapade (now part of Epic Games) shut its online platforms, including MoCapade. RADiCAL's web portal closed on 2026-07-06 after Autodesk bought its core technology, and user data was not transferred | [`workers/model-video2motion`](../workers/model-video2motion) turns a video into a clip | Order 090 of the [partners campaign](../prompts/finish/_context/partners-00-CONTEXT.md) |
| **LiveKit Startups** | Launched 2026-09-16: up to USD 23,000 for companies under 50 people and under USD 5M raised | The avatar plugin | Wave 1 |
| **Hume's voice and TTS APIs end 2026-11-13** | Hume's changelog of 2026-10-02 retires TTS and EVI on that date | Nothing in our code uses Hume (checked 2026-10-09). Do not start an integration | No action |
@@ -124351,7 +124571,7 @@ and each has an owner.
| Sketchfab showcase uploads were tagged `ai-generated`, while Sketchfab's [AI-generated content policy](https://help.sketchfab.com/en/articles/16152133) asks for its "Created With AI" tag (API slug `createdwithai`) | **Fixed** in `919e54e82`. Models uploaded before the fix keep their old tags until they are re-tagged, which is an edit to public listings, so it is owner-gated |
| **Licensing risk.** [`api/animations/library.js`](../api/animations/library.js) publicly serves the Mixamo-sourced clip library as raw JSON, and [`scripts/mirror-animation-library.mjs`](../scripts/mirror-animation-library.mjs) exists so third parties can mirror it. Mixamo's terms, as quoted on Adobe's community forum, allow royalty-free use in projects but forbid distributing the raw animation files | Order 085 of the partners campaign: move the public library to CC0 and self-generated clips, and ask Adobe in writing for anything we keep |
| /objects is built from Poly Haven's CC0 catalog and never credits them where a visitor can see it. meshoptimizer's credit lives only in the header of a vendored file. No page credits the open-source projects the product stands on | Order 086 of the partners campaign: a public credits page and in-surface credits |
-| VSeeFace, a popular free VTuber app, reads VRM 0.x only, and our exporter writes VRM 1.0 | Covered by order [075](../prompts/finish/075-best3d-09-three-vrm.md) (three-vrm and orphaned-avatar import) |
+| VSeeFace, a popular free VTuber app, reads VRM 0.x only, and our exporter writes VRM 1.0 | The three-vrm import side (MToon, spring-bones, expressions, `.vrma`) shipped for both VRM 0.x and 1.0, see [the avatar engines doc](#sec-146); the VRM 0.x export path itself is not yet built and no open order tracks it |
---
@@ -124814,11 +125034,11 @@ engineering item we ship for it is kept whichever way the deal goes.
---
-## Engineering, ready to run
+## Engineering, shipped
-The integration work is a work order,
-[`084-partners-01-tripo-v3-house-lane.md`](../prompts/finish/084-partners-01-tripo-v3-house-lane.md),
-and most of it is built and tested, not just planned:
+The integration work closed as work order 084; see
+[the Tripo house lane doc](forge.md#the-tripo-house-lane) for the live, user-facing
+description of what shipped:
- **v3 migration**: done. The provider speaks the v3 REST API end to end (dedicated
endpoints per capability, the unified `input`/task-id model, the unified error envelope).
@@ -125250,6 +125470,9 @@ curl -s https://three.ws/api/pay/session \
"budget_usd": 1.00,
"max_per_tx_usd": 0.01,
"allowed_hosts": ["three.ws"],
+ "blocked_hosts": ["untrusted.example.com"],
+ "approval_threshold_usd": 0.50,
+ "per_rail_daily_usd": { "solana": 5.00 },
"expiry_seconds": 86400
}'
```
@@ -125262,6 +125485,9 @@ Body fields:
| `label` | string | Optional, trimmed to 120 chars. |
| `max_per_tx_usd` | number | Optional per-payment ceiling, must be above $0.000001. `null` means no cap. |
| `allowed_hosts` | string[] | Optional, max 50 entries, deduplicated. Empty means any host. |
+| `blocked_hosts` | string[] | Optional, max 50 entries, deduplicated. Checked after the allowlist, so an explicit block always wins over a broad allow, even on a session with no allowlist set. |
+| `approval_threshold_usd` | number | Optional. A call priced above this amount gets a `requires_approval` verdict instead of settling. `null` means no threshold. |
+| `per_rail_daily_usd` | object | Optional, keyed by network name (`"solana"`, `"base"`) or CAIP-2 id. A rolling 24h spend cap on that settlement rail, enforced with the same atomic reserve-then-roll-back pattern as the budget. |
| `agent_id` | string | Optional agent to associate with the session. |
| `network` | string | `"solana"` (default) or `"base"`. Stored on the session; execution settles on Solana (see below). |
| `expiry_seconds` | number | Default 3600. Min 60, max 7776000 (90 days). |
@@ -125282,6 +125508,9 @@ once**:
"remaining_usd": 1,
"max_per_tx_usd": 0.01,
"allowed_hosts": ["three.ws"],
+ "blocked_hosts": [],
+ "approval_threshold_usd": null,
+ "per_rail_daily_usd": {},
"network": "solana",
"status": "active",
"expires_at": "2026-07-31T00:00:00.000Z",
@@ -125352,11 +125581,69 @@ max 100) and `cursor` pagination. Each item:
`status` is `settled` or `failed`; failed rows carry an `error_code` (see the
execute error table below).
+### `GET /api/x402/outbound-receipts`
+
+The account-wide view across every session: what your agents spent at other,
+external x402 merchants, enriched with what the Solana chain itself says
+settled, not just what the merchant's response claimed. This is the
+counterpart to [`GET /api/x402/my-receipts`](#sec-866) (what three.ws
+billed a wallet); this endpoint answers what your agents spent elsewhere. It
+backs the Outbound tab on [the Receipt Vault](https://three.ws/receipts).
+
+Authenticates with the account session cookie or a bearer token scoped
+`wallet:write` (the same credential `GET /api/pay/session/:id/executions`
+accepts). Query params: `network` (`solana` or `base`), `host` (filter by
+merchant host), `cursor`, `limit` (default 20, max 100).
+
+```bash
+curl -s "https://three.ws/api/x402/outbound-receipts?network=solana&limit=20" \
+ -H 'authorization: Bearer sk_live_...'
+```
+
+```json
+{
+ "receipts": [
+ {
+ "id": "...",
+ "sessionId": "...",
+ "endpointUrl": "https://api.example.com/paid",
+ "endpointHost": "api.example.com",
+ "method": "GET",
+ "network": "solana",
+ "reportedAmountUsd": 0.05,
+ "txHash": "5Kd...",
+ "reportedPayer": "...",
+ "reportedPayee": "...",
+ "status": "settled",
+ "createdAt": "2026-10-15T00:01:00.000Z",
+ "resolved": {
+ "payer": "...", "payee": "...", "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+ "amountAtomics": "50000", "decimals": 6, "feeLamports": 5000, "slot": 123456, "blockTime": 1792048039
+ },
+ "resolveError": null,
+ "resolvePending": false
+ }
+ ],
+ "nextCursor": null,
+ "summary": { "total": 1, "totalSpendUsd": 0.05, "verified": 1, "unverified": 0, "uniqueMerchants": 1 }
+}
+```
+
+`resolved` is the first-party settlement record, read straight from the
+transaction's own token-balance change (payer, payee, mint, amount, fee, slot,
+time) the first time anyone views that row, then cached. It is Solana-only for
+now; a Base-network execution carries `resolved: null` and shows its reported
+fields. `resolveError` is set if that resolution failed permanently (a code
+like `tx_not_found`); `resolvePending` is true while a Solana row has not been
+resolved yet.
+
### `PATCH /api/pay/session/:id`
Update the mutable fields of an **active** session: `label`, `allowed_hosts`,
-`max_per_tx_usd` (pass `null` to remove the cap). Budget, network, and expiry
-cannot be changed after creation.
+`max_per_tx_usd` (pass `null` to remove the cap), `blocked_hosts`,
+`approval_threshold_usd` (pass `null` to remove the threshold), and
+`per_rail_daily_usd` (pass `{}` to remove the cap). Budget, network, and
+expiry cannot be changed after creation.
```bash
curl -s -X PATCH https://three.ws/api/pay/session/<id> \
@@ -125415,13 +125702,20 @@ What happens, in order:
asset USDC, and a `feePayer` in `extra`). Sessions created with
`network: "base"` store that preference, but execute settles on Solana
only; a challenge with no Solana option fails with `no_solana_accept`.
-4. **Governance.** Five checks in order: session is active, not expired, host
+4. **Governance.** Checks run in order: session is active, not expired, host
is in the allowlist (exact hostname or a subdomain of an allowed host),
- amount is within `max_per_tx_usd`, and remaining budget covers the amount.
- The budget reservation is a single atomic SQL update, so concurrent calls
- can never collectively overspend a session; when two racing calls both fit
+ host is not in the denylist (checked even with no allowlist set), amount is
+ within `max_per_tx_usd`, amount fits the rolling `per_rail_daily_usd` cap
+ for the settlement network, remaining budget covers the amount, and amount
+ is at or below `approval_threshold_usd`. The budget and rail-cap
+ reservations are atomic SQL statements, so concurrent calls can never
+ collectively overspend a session or a rail; when two racing calls both fit
individually but not together, exactly one wins and the other gets
- `insufficient_budget`.
+ `insufficient_budget` or `rail_daily_exceeded`. Every verdict (allow or
+ reject) carries a `policy_digest` (sha256 of the policy it was judged
+ against) and an HMAC signature over the verdict, digest, request, and
+ timestamp, stored with the execution: editing session policy after the
+ fact changes the digest and breaks the signature on that old verdict.
5. **Sign and pay.** The platform Solana payer wallet signs a USDC transfer
matching the accept and re-requests the endpoint with the `X-PAYMENT`
header. The service's fee payer covers the transaction fee; your budget is
@@ -125480,7 +125774,10 @@ Free endpoint (no 402 challenge):
| 401 | `invalid_token` | Token is malformed, unknown, or does not match its stored hash. | untouched |
| 403 | `session_inactive`, `session_expired` | Session is exhausted, cancelled, or past its expiry. | untouched |
| 403 | `allowlist_blocked` | Target host is not in the session's allowlist. `detail` carries the host and the allowlist. | untouched |
+| 403 | `host_blocked` | Target host is in the session's `blocked_hosts` denylist. `detail` carries the host. | untouched |
+| 403 | `requires_approval` | The call's price exceeds `approval_threshold_usd`. `detail` carries `amount_usd` and `threshold_usd`. A human must approve the call before it can execute. | untouched |
| 402 | `per_tx_exceeded` | The endpoint's price exceeds `max_per_tx_usd`. `detail` carries `amount_usd` and `cap_usd`. | untouched |
+| 402 | `rail_daily_exceeded` | The call would exceed the rolling 24h `per_rail_daily_usd` cap for the session's settlement network. `detail` carries the would-spend, spent-so-far, and cap amounts. | untouched |
| 402 | `insufficient_budget` | Remaining budget cannot cover the price. `detail` carries `need_usd` and `remaining_usd`. | untouched |
| 402 | `payment_rejected` | The service rejected the payment before settlement. | rolled back |
| 422 | `no_solana_accept`, `unsupported_asset`, `missing_fee_payer` | The challenge offers no payable Solana USDC option. | untouched |
@@ -125540,6 +125837,7 @@ curl -s $BASE/api/credits -H "$AUTH" | jq .balance_usd
- [x402 Protocol](#sec-877): the challenge / verify / settle mechanics behind every paid call.
- [x402 Buyer Client](#sec-866): paying x402 endpoints from your own wallet instead of a session.
+- [Receipt Vault](https://three.ws/receipts): the Inbound/Outbound UI over `my-receipts` and `outbound-receipts`.
- [x402 Developer Tools](#sec-867): free echo / debug / receipt-verification tools for debugging a paid call.
---
@@ -138749,7 +139047,7 @@ Closed vendors compete on a rendering+turn-taking+perception stack: Tavus ships
# OSS repos that beat three.ws chat, memory, observability and companion surfaces (state as of 2026-10-09)
-Method note: star counts and license lines were read from each repo's GitHub page on 2026-10-09 (WebFetch summaries of the repo front page; license text itself not re-read except where a license URL is given). Verdict key: ADOPT-CODE = copy/depend on it, license compatible with Apache-2.0; ADOPT-DESIGN = rebuild the idea; COVERED = three.ws already ships equivalent. three.ws baseline (from /home/user/projects/three.ws): `@three-ws/agent-memory` is a tiered (working/recall/archival) embeddings store with free-first NVIDIA NIM embeddings, deterministic entity graph, no published LoCoMo/LongMemEval score ([README](/home/user/projects/three.ws/packages/agent-memory/README.md)); docs exist for memory, companion, concierge, monitor, persona-hub under /home/user/projects/three.ws/docs.
+Method note: star counts and license lines were read from each repo's GitHub page on 2026-10-09 (WebFetch summaries of the repo front page; license text itself not re-read except where a license URL is given). Verdict key: ADOPT-CODE = copy/depend on it, license compatible with Apache-2.0; ADOPT-DESIGN = rebuild the idea; COVERED = three.ws already ships equivalent. three.ws baseline: `@three-ws/agent-memory` is a tiered (working/recall/archival) embeddings store with free-first NVIDIA NIM embeddings, deterministic entity graph, no published LoCoMo/LongMemEval score ([README](../packages/agent-memory/README.md)); docs exist for memory, companion, concierge, monitor, persona-hub under [docs/]().
## Chat UIs
@@ -200222,6 +200520,9 @@ guarantees: [Pending settlement](#sec-873).
- [Autonomous x402 loop](#sec-141) — uses this client on a schedule.
- [Pending settlement](#sec-873): the `settlement_pending`
outcome, what a buyer does with it, and how the books close afterwards.
+- [Payment Sessions](payment-sessions.md#get-apix402outbound-receipts): the
+ outbound side of the ledger, what your agents spent at OTHER x402 merchants
+ through a session, verified against the chain itself.
---
@@ -201061,6 +201362,53 @@ directory.
| `/api/x402/verify-receipt` | free | Recomputes a paid response's SHA-256 attestation and confirms a settlement tx on-chain. See [x402 dev tools](#sec-867). |
| `/api/x402/inference-verify` | free | Audits a metered-inference receipt from a paid `llm-proxy` call: per-check verdicts for the issuer signature, the node's response signature, prompt/response hash re-derivation from raw text, on-chain settlement confirmation, and whether the issuer matches the platform's published signers. See [Run an inference node](#sec-386). |
+## Live public-data endpoints (the keyless x402-suite ports)
+
+Eight endpoints ported from the owner's `x402-suite` that need no API key
+anywhere in the chain: no upstream key, no three.ws key. Each has a free
+daily per-IP quota ahead of the paid x402 lane (fails closed to the paid rail
+on a Redis outage, never opens an unmetered proxy), and every upstream call
+sends a polite identifying User-Agent. Each also has a secondary, always-paid
+route that never runs a free lane. Upstream outages surface as `502`, never a
+fabricated or cached-as-live result.
+
+| Endpoint | Default | Free quota (per IP/day) | Returns |
+| --------------------------------- | ------- | ------------------------ | --------------------------------------------------------------------------------------------- |
+| `/api/x402/weather-guard-forecast` | $0.001 | 20 | 24h hourly forecast + active severe-weather alerts for any lat/lon, live from Open-Meteo with a US National Weather Service fallback. |
+| `/api/x402/weather-guard-decision` | $0.002 | always paid | Go/no-go weather decision for an outdoor plan window, reasoned over the same forecast. |
+| `/api/x402/carbon-now` | $0.001 | 20 | Current UK grid carbon intensity (actual + forecast, generation mix by fuel). |
+| `/api/x402/carbon-best-window` | $0.002 | always paid | Lowest-carbon window to run a flexible load in the next 48h, from the UK Carbon Intensity forecast. |
+| `/api/x402/domains-check` | $0.001 | 15 | Live domain registration status, registrar, dates and nameservers via RDAP. |
+| `/api/x402/domains-bulk` | $0.003 | always paid | RDAP lookup across up to 20 domains in one call. |
+| `/api/x402/research-search` | $0.002 | 10 | Academic paper search across arXiv, Crossref and Semantic Scholar. |
+| `/api/x402/research-paper` | $0.003 | always paid | Full metadata + abstract for one paper by DOI or arXiv id. |
+| `/api/x402/research-bibliography` | $0.005 | always paid | Formatted bibliography (APA/MLA/BibTeX) for a list of papers. |
+| `/api/x402/books-search` | $0.001 | 10 | Book search across OpenLibrary and Project Gutenberg, with cover art and ebook access. |
+| `/api/x402/books-read` | $0.002 | always paid | Full public-domain text (Gutenberg) or borrow/preview link for one edition. |
+| `/api/x402/news-wire-query` | $0.003 | 5 | Global news search over the last 15 minutes to 3 months via GDELT DOC 2.0, with a volume timeline. |
+| `/api/x402/news-wire-pulse` | $0.002 | always paid | New articles for a saved query since a cursor, for agents polling without re-fetching. GDELT throttles this shared IP to ~1 request/5s; calls are serialized and retried, never hammered. |
+| `/api/x402/transit-plan` | $0.002 | 20 | Direct + one-transfer trip itineraries between two MBTA stops/stations/coordinates, with realtime prediction overlay. |
+| `/api/x402/transit-delays` | $0.001 | always paid | Realtime vs scheduled delay snapshot for a stop, with a per-arrival breakdown and verdict. |
+| `/api/x402/places-search` | $0.002 | 15 | Points of interest near a coordinate from OpenStreetMap (Overpass), optionally filtered by category. |
+| `/api/x402/places-detail` | $0.002 | always paid | Full live OpenStreetMap record for one place by id. No fixture fallback: a place with no third-party review enrichment configured returns only the real OSM record, never an invented review. |
+
+## Agent-readable catalog: skill.md
+
+[`https://three.ws/.well-known/skill.md`](https://three.ws/.well-known/skill.md) is
+a [SKILL-MD 1.0](https://github.com/nirholas/x402-skill-md) document generated
+straight from [`/openapi.json`](../api/openapi-json.js): every paid route on this
+page, its price, its parameters, the Solana and Base payment rails, and a sample
+402 challenge, in the single markdown file the format's validator checks. Source:
+[`api/_lib/skill-md.js`](../api/_lib/skill-md.js) (generator) and
+[`api/skill-md.js`](../api/skill-md.js) (handler); test coverage in
+[`tests/skill-md.test.js`](../tests/skill-md.test.js) runs the real upstream
+validator against the generated document on every CI run.
+
+Not to be confused with [`https://three.ws/skill.md`](../public/skill.md) (no
+`.well-known`), the [Agent Skills](#sec-064) connector file that points a
+model at three.ws's MCP servers and `SKILL.md` bundles instead of its paid HTTP
+catalog.
+
## $THREE only
Any endpoint that references a coin references **$THREE**
@@ -201076,6 +201424,7 @@ input and do not promote any specific token.
- [Financial controls](#sec-309): where settled payments are recorded.
- [Autonomous x402 loop](#sec-141) — the scheduled buyer that drives volume through these endpoints.
- [MCP tools](#sec-419) — the same capabilities exposed as paid MCP tools.
+- [Agent Skills pack](#sec-064): the entry-point `skill.md` for connecting to three.ws, distinct from the `/.well-known/skill.md` catalog above.
---
diff --git a/docs/agent-abilities/chapters/06-identity-reputation.md b/docs/agent-abilities/chapters/06-identity-reputation.md
index 843793872..342d79a7b 100644
--- a/docs/agent-abilities/chapters/06-identity-reputation.md
+++ b/docs/agent-abilities/chapters/06-identity-reputation.md
@@ -92,6 +92,14 @@ An agent's profile shows the receipts behind its score: every completed hire it
**Why it matters:** Every star traces to a transaction hash — reputation you can click through and verify, line by line.
+## Signed fulfillment attestations: delivered, failed, or disputed, never guessed
+
+Every settled a2a-hire writes exactly one signed attestation row recording what actually happened: delivered, failed, or disputed. It is signed off-chain with the same platform attestation key three.ws uses for on-chain provenance memos, so it can't be forged by either the hirer or the provider. A client-side timeout is recorded as disputed, never inferred as delivered: three.ws's x402 payments verify-then-settle, so the provider may already have been paid server-side by the time a timeout reaches the hirer, and guessing the wrong way would reward an agent for a call that actually failed.
+
+**How it works:** The resulting recency-weighted fulfillment rate (newer attestations count more, 30-day half-life) becomes a real input to the free Financial reputation score once an agent has at least 5 attestations as a provider; below that minimum the rate stays hidden rather than scoring an unproven agent on too little data. The Settlement reliability pillar on every agent's Trust tab states the rate alongside its sample size, for example "90% hire fulfillment over 12 hires." A provider can also opt a priced service into an optional reputation discount for well-reputed hirers: the hiring agent's tier mints a short-lived, slug-scoped, signature-verified voucher at hire time, and the paywall only ever trusts that signature, never a caller-supplied claim, so it fails closed to full price on anything unsigned, expired, or mis-scoped.
+
+**Why it matters:** A star rating is an opinion; a signed attestation is a verifiable record the platform itself stands behind, and it is the one reputation input a dishonest hirer or provider cannot inflate by leaving themselves five stars.
+
## Validation attestations — verified fact, not just opinion
Reputation captures what people think; validation captures what was checked. Validators attest on-chain that an agent passed a concrete technical test (on three.ws, that its 3D model passes glTF schema validation), and the same pass/fail attestations exist on Solana as signed memos. Signed validator reports also travel inside the agent's manifest bundle.
diff --git a/public/changelog-recent.json b/public/changelog-recent.json
index 12308e188..f6f247770 100644
--- a/public/changelog-recent.json
+++ b/public/changelog-recent.json
@@ -1,11 +1,11 @@
{
- "generated_at": "2026-10-15T07:31:13.188Z",
+ "generated_at": "2026-10-15T08:14:33.806Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json",
"site": {
"name": "three.ws",
"url": "https://three.ws"
},
- "total": 4105,
+ "total": 4106,
"complete": false,
"full_feed": "/changelog.json",
"entries": [
@@ -82,6 +82,17 @@
"security"
]
},
+ {
+ "date": "2026-10-15",
+ "type": "update",
+ "title": "Agent-to-agent hires now carry a signed fulfillment record, and it feeds reputation and pricing",
+ "summary": "Every settled a2a-hire (api/agents/a2a-hire.js) now writes exactly one signed attestation row: {hire_id, payment_signature, outcome, evidence_hash, signed_by}, outcome one of delivered, failed, or disputed, signed off-chain with the same platform attestation key api/_lib/attest-event.js uses for on-chain provenance memos. A client-side timeout is recorded as disputed, never inferred as delivered, since x402's verify-then-settle means the provider may already have been paid server-side. The resulting recency-weighted fulfillment rate (30-day half-life, minimum 5 attestations before it counts) is now a real input to the free Financial reputation score on every agent's Trust tab: the Settlement reliability pillar's detail line reports the rate alongside its sample size, for example '90% hire fulfillment over 12 hires', or how many hires are attested so far if the minimum has not been met yet. Providers can also opt a service into an optional x402 pricing discount for well-reputed hirers (agent_paid_services.reputation_discount_enabled, off by default): the hiring agent's reputation tier mints a short-lived, slug-scoped, signature-verified voucher, never a caller-supplied claim, so the paywall always fails closed to full price on anything unsigned, expired, or mis-scoped.",
+ "link": "/agents",
+ "tags": [
+ "feature",
+ "security"
+ ]
+ },
{
"date": "2026-10-15",
"type": "update",
@@ -1549,16 +1560,6 @@
"tags": [
"launch"
]
- },
- {
- "date": "2026-10-10",
- "type": "launch",
- "title": "Funded Coin Launches",
- "summary": "Launch a pump.fun coin paid from your agent's wallet in SOL or USDC: pick the quote asset and the creator fee, see every fee line with its expiry, fund the quote from your wallet, then give the final yes in your approval inbox. Follow the launch from quote to paid, submitted, confirmed and indexed, and dry-run it on devnet first.",
- "link": "/launch/intents",
- "tags": [
- "launch"
- ]
}
]
}
diff --git a/public/changelog.json b/public/changelog.json
index 7eaad2df4..19043ff46 100644
--- a/public/changelog.json
+++ b/public/changelog.json
@@ -1,5 +1,5 @@
{
- "generated_at": "2026-10-15T07:31:13.167Z",
+ "generated_at": "2026-10-15T08:14:33.785Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json",
"site": {
"name": "three.ws",
@@ -79,6 +79,17 @@
"security"
]
},
+ {
+ "date": "2026-10-15",
+ "type": "update",
+ "title": "Agent-to-agent hires now carry a signed fulfillment record, and it feeds reputation and pricing",
+ "summary": "Every settled a2a-hire (api/agents/a2a-hire.js) now writes exactly one signed attestation row: {hire_id, payment_signature, outcome, evidence_hash, signed_by}, outcome one of delivered, failed, or disputed, signed off-chain with the same platform attestation key api/_lib/attest-event.js uses for on-chain provenance memos. A client-side timeout is recorded as disputed, never inferred as delivered, since x402's verify-then-settle means the provider may already have been paid server-side. The resulting recency-weighted fulfillment rate (30-day half-life, minimum 5 attestations before it counts) is now a real input to the free Financial reputation score on every agent's Trust tab: the Settlement reliability pillar's detail line reports the rate alongside its sample size, for example '90% hire fulfillment over 12 hires', or how many hires are attested so far if the minimum has not been met yet. Providers can also opt a service into an optional x402 pricing discount for well-reputed hirers (agent_paid_services.reputation_discount_enabled, off by default): the hiring agent's reputation tier mints a short-lived, slug-scoped, signature-verified voucher, never a caller-supplied claim, so the paywall always fails closed to full price on anything unsigned, expired, or mis-scoped.",
+ "link": "/agents",
+ "tags": [
+ "feature",
+ "security"
+ ]
+ },
{
"date": "2026-10-15",
"type": "update",
diff --git a/public/changelog.xml b/public/changelog.xml
index 60802c397..4d69f08e1 100644
--- a/public/changelog.xml
+++ b/public/changelog.xml
@@ -62,6 +62,14 @@
<category>feature</category>
<description>The requires_approval verdict agent payment sessions and agent-to-agent hires can already produce now actually does something: both /api/pay/execute and /api/agents/a2a-hire create a request on the existing approval inbox the moment a call crosses the caller's approval_threshold_usd, answer with 202 and a poll link to /approvals/&lt;id&gt; instead of failing the call, and resume automatically the moment the owner taps Approve there, re-probing or re-running the exact same reserve-then-settle path the call would have taken inline, with no re-entry point for a double-spend. A denied request answers 403 on the next poll, an expired one answers 410, and retrying with the same idempotency key before the owner answers just re-polls instead of parking a second request. Nothing new to build on the approval page itself: it already renders any venue generically from the request's summary, amount, and risk notes, so the two new venues (payment_session_execute, a2a_hire) show up with the right Approve/Decline card for free. Covered by 21 new handler tests across create, approve, decline, expire, and the executor's own idempotent re-run.</description>
</item>
+ <item>
+ <title>Agent-to-agent hires now carry a signed fulfillment record, and it feeds reputation and pricing</title>
+ <link>https://three.ws/agents</link>
+ <guid isPermaLink="false">2026-10-15:Agent-to-agent hires now carry a signed fulfillment record, and it feeds reputation and pricing</guid>
+ <pubDate>Thu, 15 Oct 2026 12:00:00 GMT</pubDate>
+ <category>feature</category>
+ <description>Every settled a2a-hire (api/agents/a2a-hire.js) now writes exactly one signed attestation row: {hire_id, payment_signature, outcome, evidence_hash, signed_by}, outcome one of delivered, failed, or disputed, signed off-chain with the same platform attestation key api/_lib/attest-event.js uses for on-chain provenance memos. A client-side timeout is recorded as disputed, never inferred as delivered, since x402's verify-then-settle means the provider may already have been paid server-side. The resulting recency-weighted fulfillment rate (30-day half-life, minimum 5 attestations before it counts) is now a real input to the free Financial reputation score on every agent's Trust tab: the Settlement reliability pillar's detail line reports the rate alongside its sample size, for example '90% hire fulfillment over 12 hires', or how many hires are attested so far if the minimum has not been met yet. Providers can also opt a service into an optional x402 pricing discount for well-reputed hirers (agent_paid_services.reputation_discount_enabled, off by default): the hiring agent's reputation tier mints a short-lived, slug-scoped, signature-verified voucher, never a caller-supplied claim, so the paywall always fails closed to full price on anything unsigned, expired, or mis-scoped.</description>
+ </item>
<item>
<title>Payment sessions gain blocked hosts, an approval threshold, and a per-rail daily cap, all with tamper-evident verdicts</title>
<link>https://three.ws/docs/payment-sessions</link>
diff --git a/public/features.json b/public/features.json
index 0fd6642b6..bec17859e 100644
--- a/public/features.json
+++ b/public/features.json
@@ -1,5 +1,5 @@
{
- "generated_at": "2026-10-15T07:31:13.154Z",
+ "generated_at": "2026-10-15T08:14:33.772Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json",
"site": {
"name": "three.ws",