Skip to content

feat(spec): name Ripple's finality field for XRP and XRPT (MAG-5339) - #212

Open
Tomelia1999 wants to merge 1 commit into
mainfrom
feat/MAG-5339-ripple-finality-field
Open

Tomelia1999 wants to merge 1 commit into
mainfrom
feat/MAG-5339-ripple-finality-field

Conversation

@Tomelia1999

Copy link
Copy Markdown
Contributor

What

ripple.json, XRP and XRPT: two new spec-level settings that name the field by which a Ripple node says whether the data it answered with is final.

 "block_distance_for_finalized_data": 4,
+"finality_field_path": "result.validated",
+"finality_field_final_value": "true",

Both specs carry the settings. XRPT imports XRP, but an import brings API collections only, not spec-level values.

Why

  • A Ripple node can answer a numbered ledger read with a ledger that is not final. A node that is a few ledgers behind the network returns its own open copy of the ledger, with HTTP 200, "status": "success" and "validated": false.
  • The router's cache decided "final" from block numbers only. In one production case such a reply was 5 ledgers behind the router's tip, the spec's distance is 4, so it was kept as final and served from the cache for as long as final data lives.
  • rippled writes validated at the top level of result on every reply that reads a ledger. true means final. With these settings the router keeps a reply as final only when the block distance says so and result.validated, if present, is true.

Depends on smart-router #774

The settings are read by smart-router PR #774 (MAG-5339). A router without that change ignores them: specs are decoded with plain json.Unmarshal, which skips unknown fields. So the two can merge in either order, and this one has no effect until routers run #774.

Checked

  • A router built from smart-router main (without #774) loaded this file and served XRP normally.
  • A router built from #774 with this file, against a fake Ripple node and a real cache server, ledger 6 behind the tip, two asks 4 seconds apart:
node's reply second ask
"validated": false reaches the node (not served from the cache)
"validated": true served from the cache, as before
  • The router's own tests that read this catalogue pass against this branch: TestEveryLavaSpecHasAChainFamily, and the spec decode and loader tests in types/spec and utils/keeper.
  • Offline guards, run locally on ripple.json before and after the change, give the same result: disabled-count reports 0, node-admin-rpcs and chain-identity report no new findings, unused-fields, network-params, method-schema, verifications, extensions and stateful pass.

Not checked

  • Against a live Ripple node. The reply shape comes from the rippled source and the xrpl.org reference.
  • The websocket reply shape.

Jira ticket: MAG-5339

🤖 Generated with Claude Code

A Ripple node that is behind the network answers a numbered ledger read with
its own open copy of that ledger: HTTP 200 and "validated": false. The router
decided "final" from block numbers alone, so such a reply could be cached as
final.

Declare the field on both specs, so a router that reads it keeps a reply as
final only when the block distance says so and result.validated, if present,
is true:

  finality_field_path         "result.validated"
  finality_field_final_value  "true"

Both specs carry the settings: an import brings API collections, not
spec-level values. A router that does not know the settings ignores them.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
@magmadevs-bot

Copy link
Copy Markdown
Contributor

🤖 Spec pipeline started on PR open — running Phase 8 → 11. Results post here as comments. View run

@magmadevs-bot

Copy link
Copy Markdown
Contributor

Phase 8 — smart-router boot + multi-node method probe

Resumable run (START_PHASE=8, END_PHASE=11). Endpoint source: self_research — MAINNET_URLS/TESTNET_URLS were both empty, so public XRPL nodes were researched and live-validated over both http and wss before boot.

Input Value
Spec ripple.json — XRP (mainnet), XRPT (testnet)
Interfaces jsonrpc only (both entries) — no extra interfaces to probe
Router image ghcr.io/magma-devs/smart-router:main @ sha256:45c8efbb…a06826
Mainnet http https://xrplcluster.com, https://s1.ripple.com:51234, https://s2.ripple.com:51234
Mainnet wss wss://xrplcluster.com, wss://s1.ripple.com:51233, wss://s2.ripple.com:51233
Testnet http / wss https://s.altnet.rippletest.net:51234 / wss://s.altnet.rippletest.net:51233

The spec carries FUNCTION_TAG_SUBSCRIBE/UNSUBSCRIBE directives, so a ws upstream was a hard boot requirement. All six endpoints answered a websocket upgrade + server_info, so the ws gate did not trigger and no ws-capable-node request was needed.

Verdicts

Check Verdict
PARSE: OK — smartrouter_latest_block rising, 0 fetch fails. GET_BLOCK_BY_NUM was NOT_EXERCISED by this image's periodic tracker (the fetch_block_* metric is dead), but the pruning verification executes the identical GET_BLOCK_BY_NUM template and passed 12/12 at boot — the directive is sound, just not polled.
VERIFY: (mainnet) OK — chain-id 6/6, pruning 12/12 (base + archive tier × 3 upstreams × http/wss)
ADDONS: 1 tested-ok / 0 failed / 0 not-testable
TESTNET_VERIFY: PARTIAL — see below
BLOCK_TIME: mainnet 4090 ms vs spec 4000 ms (+2.3%, OK); testnet 3410 ms vs spec 4000 ms (−14.8%, OK — under the 20% threshold)
Counts PASS=36 FAIL=2 SKIP=2 UNPROBED=0 WARN=2 TIMEOUT=0 LOG_WARN=7

PASS=36 includes 11 PASS-existence results. UNPROBED=0 — no rate limit capped coverage.

Addon & extension coverage

Name Type Upstreams supporting Boot verification Router probe Classification
archive extension 3 / 3 (all full-history, complete_ledgers from 32570) OK PASS (lava-extension: archive returned ledger 40000) TESTED_OK

No add_on collections are declared, so there is nothing else in the matrix.

FAIL / WARN methods

  • subscribe, unsubscribe — FAIL, assessed as a router-side defect, not a spec defect. The spec's own shape ({"method":"subscribe","params":[{"streams":["ledger"]}]}) was verified correct by sending it directly to the upstream: immediate success plus streaming ledgerClosed frames. Through the router it fails with json: cannot unmarshal object into Go value of type string from DirectWSSubscriptionManager, for every valid JSON shape tried — the manager appears built around EVM's string-array eth_subscribe(["newHeads"]) parameter and cannot accept XRPL's object-shaped streams parameter. This reproduces on any XRP test against this router build and is unrelated to this PR. Carried into Phase 9/10 as a finding, but not as a reason to disable either method (positive evidence shows the chain supports both).
  • path_find — WARN. WS-only by rippled design; both upstream families correctly refuse it over HTTP (clio and rippled disagree only on the error text).
  • channel_authorize — WARN. Signing is disabled on public nodes (admin / notSupported class).

SKIP=2 are category.stateful broadcast methods, deliberately not probed.

Testnet pass — TESTNET_VERIFY: PARTIAL

chain-id passed 2/2 against the live altnet node (expected_value: "1" matched info.network_id). pruning passed on the https node-url but failed on the wss node-url: altnet's rippled WS endpoint returns a legacy nested result.closed.ledger shape instead of the modern flat result.ledger when api_version is not pinned. That excluded the wss node-url from serving, leaving XRPT with no working ws upstream in this run. Altnet is the only public XRPL testnet JSON-RPC, so no alternate ws candidate existed to cross-check. Per the Step 3.5 rules a PARTIAL is an upstream-capability finding, not a spec defect — recorded, not fixed.

Most important finding for MAG-5339

The router booted cleanly on both XRP and XRPT with no spec rejection, no "unknown field" error, and no decode error naming finality_field_path or finality_field_final_value. That is the pass condition this PR needed: the :main image (without smart-router #774) decodes specs with plain json.Unmarshal and silently ignores the two not-yet-consumed settings, so routers running today load this file unchanged.

Full probe report (docs/ripple/METHOD_PROBE_REPORT.md)

Method Probe Report — ripple

Generated: 2026-11-19T12:58:41Z
Router image: ghcr.io/magma-devs/smart-router:main @ sha256:45c8efbbbb3cc55e41cdd8e10f763bd7ffd7bbb0ca16006b19e10d9980a06826
Router config: /tmp/sr_ripple.yml (mainnet), /tmp/sr_ripple_testnet.yml (testnet)
Spec variant: XRP (jsonrpc), testnet pass: XRPT (jsonrpc)
Upstreams probed: https://xrplcluster.com (+wss://xrplcluster.com), https://s1.ripple.com:51234 (+wss://s1.ripple.com:51233), https://s2.ripple.com:51234 (+wss://s2.ripple.com:51233)
Testnet upstream: https://s.altnet.rippletest.net:51234 (+wss://s.altnet.rippletest.net:51233)

PR context (MAG-5339)

PR #212 adds two new spec-level settings to XRP and XRPT: finality_field_path: "result.validated" and finality_field_final_value: "true". These are consumed by smart-router PR #774, which is NOT present in the :main image used for this run. The router booted cleanly with no spec-rejection, no "unknown field" error, and no decode error naming either field. The older router's plain json.Unmarshal silently ignores the unrecognized fields exactly as expected — this is the pass condition for this PR. Confirmed on both the XRP (mainnet) and XRPT (testnet) boots.

Parse-directive & verification runtime check (Step 3.5) — mainnet (XRP)

Check Verdict Evidence
GET_BLOCKNUM (router latest_block) OK smartrouter_latest_block=108432542+ (rising across the run); rpc_endpoint_fetch_latest_success 75-102 per upstream, 0 fails
GET_BLOCK_BY_NUM (log hash-reads ∥ fetch_block counters) NOT_EXERCISED hash_read_lines=0; fetch_block_* metric absent (confirmed dead, per doc); rpc_endpoint_tracker_requests_total{kind="block_hash"} never appears — only kind="latest_block". Router-wide behavior on this image, not ripple-specific. Corroborating positive evidence: the pruning verification uses the SAME GET_BLOCK_BY_NUM function_tag/template and succeeded 12/12 times across all upstreams at boot (see below), so the directive itself is not broken — the periodic chain-tracker simply never exercises it for this chain on this router build.
Parse-signature log lines none —
Verification Verdict Providers OK/failed Notes
chain-id OK 6/6 (3 https + 3 wss) expected_value "0" matched on every upstream
pruning OK 12/12 (2 values × 3 upstreams × 2 node-urls) base value (latest_distance 500) and archive value (expected_value "32570") both verified on every upstream — all 3 mainnet nodes are genuinely full-history

Parse-directive & verification runtime check (Step 3.5) — testnet (XRPT)

Check Verdict Evidence
GET_BLOCKNUM OK smartrouter_latest_block=22447784 (rising); fetch_latest_success=5, 0 fails (via the surviving https node-url)
Verification Verdict Providers OK/failed Notes
chain-id OK 2/2 (https + wss) expected_value "1" matched on both node-urls
pruning PARTIAL 1/2 node-urls https://s.altnet.rippletest.net:51234 OK; wss://s.altnet.rippletest.net:51233 FAILED at boot: GET_BLOCKNUM Failed to parse Response ... result:{closed:{ledger:{...}}}. Confirmed independently: the same ledger/ledger_index:"validated" call returns the modern flat result.ledger.* shape over HTTP but the legacy nested result.closed.ledger.* / result.open.ledger.* shape over WS on this specific public altnet node (no api_version pinned) — a response-shape quirk of that one public endpoint, not a spec defect. Effect: the router excluded the wss node-url from block-tracking/serving (only the https url's fingerprint shows up in rpc_endpoint_url_latest_block/url_block_tracking), leaving no working ws upstream for XRPT in this configuration (altnet is the only public XRPL testnet JSON-RPC, so a different ws candidate could not be substituted here).

Addon & extension coverage (Step 1c + probes)

Name Type Upstreams supporting Standalone Boot verification Router probe Classification
archive extension all 3 (xrplcluster, s1.ripple.com, s2.ripple.com) — OK (12/12, see pruning above) PASS (ledger at ledger_index 40000 via router with lava-extension: archive returned valid historical data, matching the no-header call since all upstreams are full-history) TESTED_OK

No add_on (disjoint add-on collection) is declared anywhere in ripple.json — only the archive extension exists.

Method probe (mainnet, through router at localhost:3360)

Live inputs resolved before probing: latest validated ledger (~108432565+), a historical tx hash from a recent ledger, funded mainnet account rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh, earliest ledger 32570, a real mainnet AMM pair (XRP/USD via issuer rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B).

Method Classification Upstream notes Notes
account_info PASS
gateway_balances PASS
account_lines PASS
account_channels PASS
account_currencies PASS
account_tx PASS
submit SKIP stateful — would broadcast a transaction
submit_multisigned SKIP stateful — would broadcast a transaction
server_state PASS
fee PASS
tx PASS
ledger PASS
ledger_closed PASS
ledger_current PASS
server_info PASS chain-id verification also exercises this
book_offers PASS
ripple_path_find PASS
account_nfts PASS (account has 0 NFTs; empty array is still a PASS result)
account_objects PASS
account_offers PASS
noripple_check PASS
ledger_data PASS
ledger_entry PASS-existence entryNotFound (98) plausible index, not an actual ledger-entry key — method recognized and parsed correctly
transaction_entry PASS-existence transactionNotFound tx hash was from a different ledger than queried — method exists
amm_info PASS resolved a real live AMM pair
deposit_authorized PASS
nft_buy_offers PASS-existence invalidParams (31) placeholder NFTokenID rejected by format check; method recognized
nft_sell_offers PASS-existence invalidParams (31) same
path_find WARN notSupported (75) on xrplcluster; unknownCmd on s1/s2.ripple.com path_find is WS-only per rippled design (confirmed: ripple_path_find is the HTTP one-shot equivalent). xrplcluster (clio) returns an explicit notSupported: ... WebSocket-only message over HTTP; s1/s2.ripple.com (plain rippled) don't even register an HTTP handler and return unknownCmd. Node disagreement is explainable by server-type difference, not a spec defect — not re-probed over WS since the classification is input-independent.
ping PASS
random PASS
server_definitions PASS
manifest PASS-existence invalidParams (31) method recognized, no manifest on file for the given key
nft_history PASS-existence invalidParams "nft_idMalformed"
nft_info PASS-existence invalidParams "nft_idMalformed"
nfts_by_issuer PASS
feature PASS
channel_authorize WARN notSupported (75) "Signing is not supported by this server." admin/signing disabled on public nodes — maps to the noPermission/notImpl class, not a FAIL
channel_verify PASS-existence channelMalformed (45) placeholder channel id not a real channel; method recognized
vault_info PASS-existence entryNotFound "vault object not found." confirmed with a correctly-formatted 64-hex vault_id; SingleAssetVault/LendingProtocol amendments are supported-but-disabled network-wide (via feature), consistent with "not found" rather than "unsupported"
subscribe FAIL router: could not start subscription ... json: cannot unmarshal object into Go value of type string Router-side defect, not a spec defect — see dedicated section below
unsubscribe FAIL router: failed to extract subscription ID: could not extract subscription ID from params Same root cause — no subscription ever succeeded to unsubscribe from

Subscribe/unsubscribe finding (important, router-side)

The spec's own UNSUBSCRIBE function_template (and the equivalent method-style shape for subscribe) is {"jsonrpc":"2.0","id":1,"method":"subscribe","params":[{"streams":["ledger"]}]} — i.e. a JSON-RPC envelope with an object-shaped streams parameter, which is exactly how rippled's WS protocol works. This was verified correct independently:

  • Sent directly to wss://xrplcluster.com, both the native {"id":1,"command":"subscribe","streams":[...]} form AND the spec's {"method":"subscribe","params":[{"streams":[...]}]} form succeed immediately with a subscribe-confirmation frame followed by streaming ledgerClosed messages.
  • Sent to the router's WS listener (ws://localhost:3360) in the spec's own form, the router logs show it DOES route it through DirectWSSubscriptionManager (not the generic HTTP relay), but fails with upstream subscribe failed: json: cannot unmarshal object into Go value of type string. Variants tried: params:[{"streams":["ledger"]}] (spec shape) → object-unmarshal error; params:["ledger"] (array of bare strings, EVM-eth_subscribe-style) → ledger unknown parameters type string; params:"ledger" (bare string) → same "unknown parameters type string".

Conclusion: the router's generic WS-subscription relay machinery expects a simple string/array-of-strings subscription parameter (the EVM eth_subscribe(["newHeads"]) shape) and cannot currently marshal XRPL's native object-shaped {"streams":[...]} parameter through to the upstream, regardless of which JSON shape the client sends. This is a pre-existing smart-router limitation for XRPL-style subscriptions, unrelated to PR #212 (the finality-field addition) — it would reproduce on any XRP spec test against this router build. Flagging prominently per instructions since subscribe/unsubscribe are declared methods, but this is not something fixable in ripple.json.

Log-scan findings (probe window)

Level Associated method error excerpt
WARN subscribe/unsubscribe (ws) StartSubscription returned an error: ... json: cannot unmarshal object into Go value of type string (×3 variants tried)
ERROR subscribe/unsubscribe (ws) could not start subscription / error unsubscribing from subscription: failed to extract subscription ID
WARN — Null method malformed-JSON-RPC-response lines — all are the router retrying the misrouted ws subscribe payload against the HTTP upstreams (same root cause as above, not a separate finding)
WARN — 4× Circuit breaker: all providers exhausted — each corresponds to a method where all 3 upstreams consistently agreed on the same not-found/invalid-params/malformed-retry outcome (ledger_entry, transaction_entry, vault_info, and one subscribe retry); already reflected in the method table above, no separate finding
ERROR — 2× blockParsing - rpcInput is error — benign per the runbook: upstream returned an RPC error, not a directive defect
WARN — provider data not found, using default (×several, around the ws-subscription attempts) — router housekeeping noise tied to the same subscription failures

No fatal/panic lines at any point; the router remained healthy and continued serving normal method calls throughout and after the subscribe-probe window.

Testnet verification pass (Step 7)

TESTNET_VERIFY: PARTIAL

Verification Verdict Providers OK/failed Notes
chain-id OK 2/2 expected_value "1" matched on both https and wss node-urls
pruning PARTIAL 1/2 node-urls https OK; wss failed due to a response-shape quirk on the public altnet node (see Step 3.5 testnet table above) — not a spec defect, but means XRPT has no working ws upstream in this configuration

Empirical block time (Step 8)

Network RPC Empirical (ms) Spec effective (ms) Drift Verdict
mainnet https://xrplcluster.com 4090 4000 +2.25% OK
testnet https://s.altnet.rippletest.net:51234 3410 4000 -14.75% OK (under 20% threshold)

@magmadevs-bot

Copy link
Copy Markdown
Contributor

Phase 9 — parallel reviewers (3 × /review-spec, independent contexts)

Three reviewers ran /review-spec on ripple.json in fresh contexts, each writing its own numbered report and each having read the Phase 8 probe report first. All three reports are distinct (distinct md5s) and every evidence_line_number falls inside the file's 855 lines, so none reviewed stale state.

Reviewer TALLY
1 CRITICAL=1 MEDIUM=0 MINOR=1
2 CRITICAL=0 MEDIUM=1 MINOR=2
3 CRITICAL=0 MEDIUM=1 MINOR=3

Merged, deduplicated: 1 CRITICAL + 1 MEDIUM. Reviewers 2 and 3 independently found the same MEDIUM (path_find). Reviewer 1 alone found the CRITICAL, because it lives on the testnet archive path that the Phase 8 addon matrix never exercised — not a restatement of any probe row.

All three reviewers cleared this PR's own diff

The diff is exactly four added lines — finality_field_path: "result.validated" and finality_field_final_value: "true", on both XRP and XRPT. Every reviewer independently assessed the field path, the placement on both entries (an imports brings API collections, not spec-level values, so both entries genuinely need it), and the string "true", and all three found them correct. Combined with Phase 8's clean boot on the pre-#774 :main image, the MAG-5339 change itself is ready as-is.

CRITICAL — XRPT's inherited archive/pruning verification can never pass

XRPT defines no parse_directives, verifications (beyond overriding chain-id) or extensions of its own, so XRP's are merged in verbatim by the collection-inheritance rule. That includes the archive extension and the pruning verification whose archive-tier expected_value is "32570" — XRP mainnet's genesis ledger. GET_EARLIEST_BLOCK's function_template hardcodes that same literal, because XRPL's ledger_index has no earliest keyword.

Verified live by the reviewer and re-verified independently by the orchestrator against the same altnet endpoint Phase 8 used:

mainnet  complete_ledgers = 32570-108432817      ledger 32570 → status "success"
testnet  complete_ledgers = 13075065-22447950    ledger 32570 → error "lgrNotFound"

Altnet has been reset, so ledger 32570 does not exist on it and structurally never will. The archive extension is therefore nominally offered on XRPT (rule.block: 499) while no testnet provider can ever pass its pruning check — regardless of how complete that node's own testnet history is. Plausible fixes: override the pruning verification's archive expected_value on XRPT with testnet's actual earliest ledger, or drop the archive extension from XRPT given that altnet resets periodically.

MEDIUM — path_find is enabled in the HTTP JSON-RPC collection but is WS-only by rippled's design

path_find sits enabled: true in the file's single jsonrpc/POST collection. The probe failed it on all three mainnet upstreams with two independent error shapes: notSupported (75) from Clio (whose own error text names the WebSocket-only limitation) and unknownCmd from plain rippled on both s1/s2 (which never registers an HTTP handler for it at all). xrpl.org's path_find reference opens with an explicit "WebSocket API only!" warning.

This clears the free-tier bar deliberately: it is not a couple of public nodes gating an admin feature, it is a documented transport-level design corroborated by two different server implementations, so every provider serving this collection over HTTP fails every path_find call. The spec already carries the documented one-shot HTTP equivalent, ripple_path_find, which PASSed cleanly in the same run — so disabling the WS-only duplicate costs no functionality.

Dropped as MINOR / informational (not carried to Phase 10)

  • subscribe/unsubscribe use EMPTY/[""] block_parsing where ethereum.json and tendermint.json use DEFAULT/["latest"] for the same semantics. CU values and categories already match convention.
  • The subscribe/unsubscribe probe FAILs — router-side (DirectWSSubscriptionManager cannot unmarshal XRPL's object-shaped streams parameter); no spec-side fix exists. All three reviewers agreed.
  • TESTNET_VERIFY: PARTIAL — altnet's wss endpoint returning the legacy nested result.closed.ledger shape is an upstream quirk, not spec-side.
  • channel_authorize WARN — signing disabled on public nodes; admin-gated, explicitly not a disable candidate.

Both surviving gaps are pre-existing on main and independent of this PR's four-line diff. Phase 10 decides what to do with them.

@magmadevs-bot

Copy link
Copy Markdown
Contributor

Phase 10 — synthesize gaps + fix pass (+ Phase 10b smoke re-probe)

Consolidated the three Phase 9 reports into docs/ripple/FIX_LIST.md, keyed by (gap_title, evidence_line_number): 1 critical, 1 medium; 3 probe-only disable suggestions stripped. MINOR gaps dropped per the phase rules.

Decision: no spec edits applied — recorded as an auto-decision

This run is unattended, so the STOP-and-ask gate was auto-decided with the conservative default, and here is the reasoning.

Both surviving gaps are pre-existing on origin/main and independent of this PR's diff, which is exactly four added lines (finality_field_path + finality_field_final_value on XRP and XRPT). A workflow step after this run commits whatever the fix pass leaves in the working tree onto PR #212's branch. Applying either fix here would therefore silently widen a four-line finality-field PR into a semantic change to a live production spec — overriding a testnet verification value, or flipping a method to enabled: false — without a reviewer having asked for it. That is the drift class the skill's preservation guards exist to prevent, so the fix pass deliberately made no edits.

ripple.json is byte-identical to the committed spec, and the working tree is clean. Both gaps need their own ticket and their own PR; each has a concrete candidate fix recorded in FIX_LIST.md:

Gap Candidate fix for a follow-up PR
CRITICAL — XRPT's inherited archive/pruning verification can never pass (mainnet genesis ledger 32570 does not exist on altnet) Override the pruning verification's archive-tier expected_value on XRPT with testnet's real earliest ledger, or drop the archive extension from XRPT since altnet resets periodically
MEDIUM — path_find enabled in the HTTP JSON-RPC collection but WS-only by rippled's design enabled: false, directing HTTP consumers to ripple_path_find (which PASSed in the same probe run)

Phase 10a — offline static gates, re-run after the (empty) fix pass

Gate Result
jq parse exit 0
check_method_schema.sh PASS (no FAIL rows)
check_unused_fields.sh PASS (no removed fields)
check_hanging_api.sh --base origin/main PASS
check_stateful.sh --base origin/main PASS
check_disabled_count.sh 0 distinct methods disabled — matches the body's <!-- disabled-count: 0 --> marker, no update needed

The removed-field guard is the one this run's rules single out: the spec carries none of the 15 fields smart-router dropped in #218 — no spec-level governance fields, no proposal.title/description, no top-level deposit, no extra_compute_units, no category.local, no category.subscription. The envelope is still the canonical { "proposal": { "specs": [ … ] } }, compute_units remains the only compute-unit input, and the two subscription methods are subscriptions purely by virtue of their FUNCTION_TAG_SUBSCRIBE parse directive. Trivially satisfied here, since nothing was edited.

check_hanging_api.sh reports two === INFO === rows — submit and submit_multisigned carry hanging_api: true with no explicit timeout_ms. Both are marked [pre-existing: the base fails this row identically], so they are advisory and do not block.

Disabled-API Justifications ledger: (none — no disabled APIs).

Phase 10b — smoke re-probe: SMOKE: OK

Re-booted the router against the artifact on disk and re-probed the deterministic set. No regressions. Run on the :latest tag (sha256:476faaac…66f1da) where Phase 8 used :main, so this is also an independent second router build loading the file.

# Probe Phase 8 Phase 10b Verdict
1 GET_BLOCKNUM (ledger, validated) PASS PASS — ledger 108432882 no change
2 chain-id (server_info → info.network_id) OK (6/6) PASS — network_id: 0 matches "0" no change
3 account_channels PASS PASS no change
4 account_currencies PASS PASS no change
5 account_info PASS PASS no change
6 account_lines PASS PASS no change
7 account_nfts PASS PASS no change
addon archive extension (ledger @ 40000, lava-extension: archive) TESTED_OK PASS — 2013 close_time returned no change

PARSE: OK — smartrouter_latest_block rising, fetch_latest_success 12/upstream, 0 fails, no parse-signature lines. One transient context deadline exceeded against s1.ripple.com self-recovered on the next tick. GET_BLOCK_BY_NUM is NOT_EXERCISED again, identically to Phase 8 — this router build never periodically polls it.

VERIFY: OK — no [-] verify, no failed verification on provider startup, no Bad verification definition; all three providers logged Provider validated successfully. pruning logged 6/6 [+] verified successfully against Phase 8's 12/12; the smoke tester attributes the smaller count to a :latest-vs-:main logging difference rather than a functional gap, since the live archive probe succeeded and nothing failed. ADDONS: 1 tested-ok / 0 failed / 0 not-testable.

No fatal/panic at any point, and no genuine rate limiting. Container torn down.

@magmadevs-bot

Copy link
Copy Markdown
Contributor

Phase 11 — final reviewer verdict: ⚠️ CHANGES REQUESTED

TALLY: CRITICAL=1 MEDIUM=1 MINOR=1

Per the pipeline's rule the verdict is CHANGES REQUESTED — any remaining CRITICAL or MEDIUM gap produces that verdict, and this run reports it without upgrading. The nuance below matters for deciding what to do with it, but it does not change the verdict.

What the verdict is and is not about

The final reviewer ran in a clean context, re-verified both surviving gaps with fresh live curl calls of its own rather than reusing Phase 8's output, and reached its conclusions on the merits rather than by deferring to Phase 10's decision. It found:

  • PR feat(spec): name Ripple's finality field for XRP and XRPT (MAG-5339) #212's own four-line diff: no defect. Live against xrplcluster.com, a {"method":"ledger","params":[{"ledger_index":"validated",…}]} call returns result.validated == true — exactly the path the PR names, on exactly the ledger call this spec's GET_BLOCKNUM/GET_BLOCK_BY_NUM directives already use. The same holds on altnet, so the field resolves identically for XRP and XRPT. "true" as a quoted string matches the file's own convention ("0", "1", "32570" are all string-encoded numerics). Placement on both entries is required, not redundant: imports merges only api_collections, never spec-level scalars — and XRPT already repeats block_distance_for_finalized_data, blocks_in_finalization_proof, average_block_time and allowed_block_lag_for_qos_sync verbatim for that reason. Backward compatibility holds per Phase 8's clean boot on the pre-#774 image.
  • All three findings are pre-existing on origin/main, confirmed by git diff origin/main...HEAD -- ripple.json, which shows only the two finality fields on each entry. None was introduced by this PR.
  • Disabled-API audit: clean. Zero enabled: false entries anywhere in the file, matching the empty ledger — no CRITICAL finding on that axis.
  • Removed-field guard: PASS. Canonical { "proposal": { "specs": [ … ] } } envelope, none of the 15 fields removed in smart-router #218.

So the verdict reflects the state of ripple.json as a whole, not a problem with the change under review.

The findings

Severity Finding Introduced by this PR?
CRITICAL XRPT's inherited archive/pruning verification can never pass — GET_EARLIEST_BLOCK hardcodes ledger 32570 (XRP mainnet's genesis), which altnet's rolling history window structurally excludes forever No — pre-existing on main
MEDIUM path_find is enabled: true in the HTTP JSON-RPC collection despite being WS-only by rippled's design; Clio returns notSupported (75) naming the limitation, plain rippled returns unknownCmd No — pre-existing on main
MINOR subscribe/unsubscribe use EMPTY/[""] block_parsing where ethereum.json and tendermint.json use DEFAULT/["latest"] for the same semantics No — pre-existing on main

One detail strengthens the CRITICAL: altnet's complete_ledgers window had already moved between Phase 8 and this pass (13075065-22447950 → 12929081-22448109), which is direct evidence that the gap is structural rather than a transient history gap. Mainnet still answers ledger 32570 with real 2013 ledger data, so the value is correct for XRP — just never for XRPT.

Recommendation for the human reviewer

The verdict is CHANGES REQUESTED on the file, while the change under review is clean and all three findings predate it. Two defensible paths, and this is a human call the pipeline should not make:

  1. Merge feat(spec): name Ripple's finality field for XRP and XRPT (MAG-5339) #212 on its own merits and open a follow-up ticket for the CRITICAL and MEDIUM. This matches Phase 10's recorded conservative default and keeps the four-line finality-field change reviewable.
  2. Widen feat(spec): name Ripple's finality field for XRP and XRPT (MAG-5339) #212 to also fix the XRPT archive/pruning gap and path_find. That clears the verdict in one PR but turns it into a semantic change to a live production spec, which needs explicit sign-off.

The pipeline took path 1 by default and left the spec untouched; nothing is blocking path 2 if you prefer it.

Full final review report (docs/ripple/SPEC_REVIEW_GAPS_final.md)

Ripple (XRP / XRPT) Spec Review — Final Gap Report

Scope: ripple.json, final pass on PR #212 (MAG-5339). mode=OPEN was passed as the API-docs
argument but does not resolve to an actual OpenAPI/doc file in this repo, so Phase 3's
doc-diff could not be run against a machine-readable spec; API completeness below is
assessed from the rippled/Clio JSON-RPC surface (domain knowledge) plus the live method
probe already on file. Live-network evidence combines docs/ripple/METHOD_PROBE_REPORT.md
and fresh independent curl checks against the same public endpoints, run during this pass.

What Phase 10 did: zero spec edits. ripple.json is byte-identical to origin/main except
for this PR's own four-line diff:

+ "finality_field_path": "result.validated",
+ "finality_field_final_value": "true",

added identically to both XRP (lines 9-10) and XRPT (lines 823-824). docs/ripple/FIX_LIST.md
records the reasoning: the two surviving Phase 9 gaps are both pre-existing on origin/main and
independent of this diff, so Phase 10 reported rather than fixed them. This pass re-reviews the
file as it stands, independent of that decision, and reaches the same conclusion on the merits
(not merely by deferring to it) — see verification below.

Phase 0 — Removed-field guard

$ bash .claude/skills/create-spec/scripts/check_unused_fields.sh ripple.json
RESULT: PASS (no removed fields)

Exit 0. No cleanup findings. internal_path is present only as the default empty string
("") everywhere it appears, so check_internal_paths.sh is not applicable.

Canonical envelope { "proposal": { "specs": [ ... ] } } confirmed — no title,
description, deposit, or any of the other removed governance/spec fields. Per the
review's settled decisions, this is correct and not a finding.

Disabled-API / disabled-collection audit

$ jq '... | select(.enabled==false) ...' ripple.json
(no output — zero disabled apis, zero disabled collections)

ripple.json has no enabled: false entries anywhere (checked every API across both
XRP and XRPT, and every api_collections[] entry). The provided Disabled-API
Justifications ledger is correspondingly empty ("none — no disabled APIs"). Ledger and file
agree — no CRITICAL finding here.

PR #212's own diff — finality_field_path / finality_field_final_value

Verdict: correct, no defect. Re-verified independently and freshly in this pass (not just
inherited from Phase 9's three reports, which also found no defect):

  • Live curl against https://xrplcluster.com with {"method":"ledger","params":[{"ledger_index":"validated",...}]} right now returns a result object with keys
    ["ledger","ledger_hash","ledger_index","validated","status"] and result.validated == true
    (boolean). This is exactly the result.validated path the PR names, on exactly the ledger
    call this spec's own GET_BLOCKNUM/GET_BLOCK_BY_NUM directives already use.
  • Same check against testnet (https://s.altnet.rippletest.net:51234) also returns
    result.validated == true, confirming the field resolves identically on both XRP and
    XRPT's underlying transport.
  • finality_field_final_value: "true" as a quoted string (rather than a bare JSON boolean)
    matches this file's own pre-existing convention of string-encoding every
    verification/comparison value regardless of the wire type ("expected_value": "0", "1",
    "32570" are all strings for numeric fields). Not a new or inconsistent pattern.
  • Placement on both XRP and XRPT is required, not redundant: imports only merges
    api_collections (APIs/headers/parse_directives/verifications/extensions); spec-level
    scalars are never inherited. XRPT already independently repeats
    block_distance_for_finalized_data, blocks_in_finalization_proof, average_block_time,
    and allowed_block_lag_for_qos_sync verbatim rather than relying on imports: ["XRP"] for
    them — the PR's two new fields follow that same established pattern correctly.
  • Backward compatibility: docs/ripple/METHOD_PROBE_REPORT.md confirms a router image without
    smart-router PR #774 (plain json.Unmarshal) boots cleanly on both XRP and XRPT with no
    unknown-field rejection or decode error naming either key — this is the pass condition for a
    additive, forward-compatible field and it holds.

No issues found in the PR's actual four-line diff.

Findings

CRITICAL — XRPT's inherited archive/pruning verification can never pass (pre-existing, not introduced by this PR)

  • Target: XRPT entry (lines 818-853). It defines no parse_directives and no
    extensions of its own, and overrides only the chain-id verification's expected_value
    — so it inherits XRP's GET_EARLIEST_BLOCK directive (lines 754-766) and the pruning
    verification's archive-tier value (lines 790-804, "expected_value": "32570") verbatim via
    the collection merge rule.
  • GET_EARLIEST_BLOCK's function_template (line 756) hardcodes the literal ledger
    number 32570 — XRP mainnet's well-known post-2012-history-loss genesis ledger. There is no
    "earliest" keyword in XRPL's ledger_index grammar (confirmed: passing the string
    "earliest" returns invalidParams), so this number is the only way the directive can ask
    for "the earliest ledger," and it is mainnet-specific.
  • Verified live, independently, during this pass (not reused from the probe report):
    $ curl -s -X POST --data '{"method":"ledger","params":[{"ledger_index":32570,...}]}' \
        https://s.altnet.rippletest.net:51234
    {"result":{"error":"lgrNotFound","error_code":21,"error_message":"ledgerNotFound",...}}
    
    $ curl -s -X POST --data '{"method":"server_state","params":[{}]}' \
        https://s.altnet.rippletest.net:51234
    "complete_ledgers":"12929081-22448109"   # altnet's history window has moved again since
                                              # the probe report was written — confirms this is
                                              # a structural, not transient, defect
    
    For contrast, mainnet (https://xrplcluster.com) still answers ledger 32570 with real
    ledger data (ledger_hash, close_time_human: "2013-Jan-01...", etc.) — the value is
    correct for XRP, just not for XRPT.
  • Impact: XRPT nominally offers the archive extension (cu_multiplier: 5,
    rule.block: 499, inherited from XRP) and the pruning verification, but no testnet
    provider can ever pass the archive-tier pruning check — the directive requests a ledger
    number that altnet's rolling history window structurally excludes forever (it resets
    periodically and never retains back to 32570). The archive extension is effectively
    dead/unusable on XRPT today, and will stay that way regardless of which provider serves it
    or how complete that provider's own testnet history is.
  • Disposition: pre-existing on origin/main, independent of this PR's diff (confirmed via
    git diff origin/main...HEAD -- ripple.json — only the two finality fields changed). Phase
    10's FIX_LIST.md recorded this and chose not to fix it in this PR to avoid widening a
    four-line finality-field change into a semantic change on a live production spec. Reviewed
    independently here on the merits, re-verified live, and the conclusion is the same: this is a
    live defect in the file under review and should be tracked and fixed in its own PR (e.g.
    override XRPT's pruning archive expected_value with testnet's actual earliest ledger, or
    drop the archive extension from XRPT given altnet's resets).

MEDIUM — path_find enabled in the HTTP JSON-RPC collection despite being WS-only by rippled's own design (pre-existing, not introduced by this PR)

  • Target: XRP entry, path_find API (lines 497-511), sitting in the single
    {"api_interface":"jsonrpc","type":"POST","add_on":""} collection with "enabled": true and
    ordinary EMPTY block_parsing — configured identically to every other HTTP-servable method
    in the file, with nothing marking it as WS-only.
  • Verified live, independently, during this pass:
    $ curl -s -X POST --data '{"method":"path_find","params":[{"subcommand":"create", ...}]}' \
        https://xrplcluster.com
    {"result":{"error":"notSupported","error_code":75,
      "error_message":"path_find is WebSocket-only; use ripple_path_find without subcommand
      for a one-shot search", ...}}
    
    Clio's own error message names the limitation explicitly and even points to the correct
    replacement. docs/ripple/METHOD_PROBE_REPORT.md additionally shows plain rippled
    (s1.ripple.com, s2.ripple.com) doesn't register an HTTP handler for it at all
    (unknownCmd) — two independent server implementations, all three mainnet upstreams, 100%
    reproducible, input-independent.
  • Impact: any consumer calling path_find through a provider serving this collection over
    HTTP gets a guaranteed error on every provider, regardless of provider quality or
    configuration — the spec is contracting for something it cannot deliver over its only
    declared transport. The file already carries the documented one-shot HTTP equivalent,
    ripple_path_find (PASSed cleanly in the same probe run), so disabling the WS-only duplicate
    loses no functionality.
  • Disposition: pre-existing on origin/main, independent of this PR's diff. Candidate fix
    for a follow-up PR: "enabled": false on path_find, directing HTTP consumers to
    ripple_path_find.

MINOR — subscribe/unsubscribe use EMPTY/[""] block_parsing instead of the cross-chain DEFAULT/["latest"] convention (pre-existing, not introduced by this PR)

  • Target: XRP entry, subscribe (lines 685-699) and unsubscribe (lines 700-714).
  • Evidence: both ethereum.json's eth_subscribe/eth_unsubscribe and
    tendermint.json's subscribe/unsubscribe — the same semantic methods, confirmed by jq
    against those files — use block_parsing: {"parser_arg": ["latest"], "parser_func": "DEFAULT"}. ripple.json uses {"parser_arg": [""], "parser_func": "EMPTY"} for both. CU
    values (1000 / 10) and category already match the ETH1/TENDERMINT convention correctly;
    only block_parsing diverges.
  • Impact: low — these are WS-only streaming calls, and their own JSON-RPC ack responses
    carry no block data either way, so this is unlikely to break anything outright. But it
    diverges from the established cross-chain convention specifically for subscription methods,
    and DEFAULT/["latest"] is what associates these calls with the provider's current block
    height for affinity/QoS bookkeeping — EMPTY forfeits that association for no apparent
    reason specific to XRPL.
  • Disposition: pre-existing on origin/main, independent of this PR's diff.

Informational — probe items correctly treated as non-spec-defects (not counted in the tally)

  • subscribe/unsubscribe FAIL (router-side). The spec's own template shape
    ({"method":"subscribe","params":[{"streams":["ledger"]}]}) was verified directly against
    wss://xrplcluster.com and works correctly (subscribe-ack followed by streaming
    ledgerClosed frames). The failure through the router is inside the smart-router's
    DirectWSSubscriptionManager, which expects a bare-string/array-of-strings parameter
    (the EVM eth_subscribe(["newHeads"]) shape) and cannot unmarshal XRPL's native
    object-shaped streams parameter under any variant tried. No spec-side fix exists; this
    would reproduce for any XRPL-style subscription spec on this router build and is unrelated
    to PR feat(spec): name Ripple's finality field for XRP and XRPT (MAG-5339) #212.
  • Testnet wss://s.altnet.rippletest.net:51233 legacy-shape response. That one public
    altnet node answers the ledger call with the legacy nested result.closed.ledger.* shape
    over WS instead of the modern flat result.ledger.* shape the GET_BLOCKNUM/
    GET_BLOCK_BY_NUM directives expect — a quirk of that specific public endpoint (no
    api_version pinned), not a defect in the directives (independently proven correct: mainnet
    6/6, testnet https-side 1/1, and this pass's own fresh curl against the https endpoint
    returned the modern flat shape with validated: true cleanly).
  • channel_authorize WARN (notSupported, "Signing is not supported by this server.").
    Admin/signing disabled on these specific public nodes — a free-tier/node-config limitation,
    not documented chain-level unsupported behavior, per the settled rule that probe errors on
    the provided nodes never justify disabling a method.

Phase 2 — Network parameters (re-checked, not flagged)

Parameter Value Assessment
average_block_time 4000ms (both) Empirically confirmed by the probe: mainnet measured 4090ms (+2.25% drift), testnet measured 3410ms (-14.75% drift), both within the 20% OK threshold.
block_distance_for_finalized_data 4 Pre-existing, untouched by this PR. Not flagged.
blocks_in_finalization_proof 3 Pre-existing, untouched by this PR. XRPL's RPCA consensus has a defensible case for "fast/instant" classification (validated ledgers don't reorg), which per the settled rule would permit 1 — but it also has a defensible case for "unclear," whose fallback formula (max(ceil(1000/4000),3) = 3) lands on the same value already in the file. Since both readings converge on 3, this is not raised as a finding.
allowed_block_lag_for_qos_sync 3 10000/4000 = 2.5 → ceiling 3. Correct.

Summary

  • Endpoints reviewed: 42 declared APIs in XRP's single main collection (confirmed by
    jq), cross-checked against the 42-row method probe (36 PASS/PASS-existence, 2 SKIP —
    stateful submit/submit_multisigned, 2 FAIL — subscribe/unsubscribe, 2 WARN —
    path_find/channel_authorize), plus the archive extension and the chain-id/pruning
    verifications. XRPT defines zero APIs of its own (pure inheritance plus a chain-id
    override) — correct minimal-override pattern.
  • Gaps by severity: CRITICAL: 1, MEDIUM: 1, MINOR: 1. All three are pre-existing on
    origin/main and independent of this PR's diff; none were introduced by PR feat(spec): name Ripple's finality field for XRP and XRPT (MAG-5339) #212.
  • PR feat(spec): name Ripple's finality field for XRP and XRPT (MAG-5339) #212's actual diff (finality_field_path: "result.validated",
    finality_field_final_value: "true" on both XRP and XRPT): no defect found, re-verified
    live and independently in this pass. Correct field path, correct value encoding, correct
    placement on both specs, confirmed backward-compatible boot.
  • Readiness: PR feat(spec): name Ripple's finality field for XRP and XRPT (MAG-5339) #212's diff is ready to ship as-is. The CRITICAL (XRPT archive/pruning)
    and MEDIUM (path_find) findings are real, live defects in the file under review, but both
    are pre-existing and out of this PR's scope — they need their own follow-up ticket/PR rather
    than blocking this one. The MINOR finding (subscribe/unsubscribe block_parsing
    convention) is low-impact and likewise pre-existing.

TALLY: CRITICAL=1 MEDIUM=1 MINOR=1

@magmadevs-bot

Copy link
Copy Markdown
Contributor

Phase 12 — closing summary checklist (tail of Phase 11; no separate Phase 12 in this run span)

Legend: ✓ verified by this run · ~ partially verified · ☐ out of skill scope, surfaced as a reminder.

#### File Validation
- ✓ JSON syntax valid                                    (Phase 10a `jq` exit 0)
- ✓ All required fields present                          (Phase 11 reviewer; Phase 10a check_method_schema PASS)
- ✓ No duplicate API names within any collection         (Phase 10a check_method_schema PASS)
- ✓ Proper indentation/formatting                        (spec untouched — byte-identical to the committed file)

#### Configuration Verification
- ~ Network parameters calculated per formulas           (Phases 1-7 not run this invocation; Phase 11 re-checked all four
                                                          and found them correct: abt 4000ms empirical-confirmed on both
                                                          networks, lag 3 = ceil(10000/4000))
- ~ All APIs tested and working                           (Phase 8: PASS=36 FAIL=2 SKIP=2 UNPROBED=0 WARN=2 TIMEOUT=0;
                                                          2 stateful methods deliberately skipped; the 2 FAILs are
                                                          subscribe/unsubscribe, router-side not spec-side)
- ~ Block parsing validated for each API                 (Phase 8 existence-tested; full per-API parse validation needs
                                                          production traffic)
- ✓ Parse directives executed by live router             (Phase 8 Step 3.5: PARSE=OK, VERIFY=OK; Phase 10b re-check on the
                                                          :latest tag: PARSE=OK, VERIFY=OK. GET_BLOCK_BY_NUM is
                                                          NOT_EXERCISED by both router builds' periodic tracker, but the
                                                          pruning verification runs the identical template and passed)
- ~ Addons & extensions tested                            (Phase 8 Step 1c: 1 tested-ok / 0 failed / 0 not-testable —
                                                          archive confirmed on all 3 full-history mainnet upstreams;
                                                          re-probed OK in 10b. NOT verified on XRPT — see the CRITICAL)
- ✓ Verifications pass on live nodes                     (Phase 8 boot-window scan: chain-id 6/6, pruning 12/12 mainnet;
                                                          Phase 10b independent second router build: VERIFY=OK)
- ☐ Compute units benchmarked under expected load        (user to measure)

#### Documentation (out of skill scope — manual reminder)
- ☐ SPEC_IMPLEMENTATION.md created
- ☐ API_REFERENCE.md created
- ☐ TESTING_GUIDE.md created
- ☐ QUICK_START.md created

#### Testnet vs Mainnet
- ✓ Mainnet spec complete                                (XRP: 42 apis, 5 parse directives, 2 verifications, archive ext)
- ✓ Testnet spec inherits correctly                      (XRPT imports XRP; Phase 11 confirmed spec-level scalars are
                                                          correctly repeated rather than inherited — which is exactly why
                                                          this PR's two fields belong on both entries)
- ✓ Chain IDs verified for mainnet AND testnet           (live network_id: mainnet 0 matches XRP's expected "0";
                                                          altnet 1 matches XRPT's expected "1" — Phase 8 Step 7, 2/2)
- ~ Both tested on respective networks                   (mainnet fully probed on 3 http + 3 wss upstreams;
                                                          TESTNET_VERIFY=PARTIAL — altnet's wss endpoint returns the
                                                          legacy nested result.closed.ledger shape and was excluded,
                                                          and altnet is the only public XRPL testnet JSON-RPC so no
                                                          alternate ws candidate existed)

#### Governance Prep (out of skill scope — manual reminder)
- ☐ Proposal JSON formatted correctly                    (envelope is the canonical { "proposal": { "specs": [ … ] } } —
                                                          no title/description/deposit; check_unused_fields PASS)
- ☐ Community feedback gathered (if applicable)

Run span and disposition

Span run Phases 8 → 11 (resumable mode, PR-open auto-start)
Phases 1-7 Not run this invocation — context was reconstructed from the committed ripple.json and the PR thread
Endpoint source self_research — both URL lists were empty, so public XRPL nodes were researched and live-validated over http and wss
ws gate Not triggered — the spec has SUBSCRIBE/UNSUBSCRIBE directives and all six candidate endpoints answered a websocket upgrade
Spec edits None. The working tree is clean and ripple.json is byte-identical to the committed file; there is nothing for the post-run commit step to push
Auto-decisions recorded (1) Phase 10 applied no fixes — both gaps pre-existing on main and out of scope for a four-line PR. (2) TESTNET_VERIFY: PARTIAL accepted as an upstream-capability finding, not a spec defect.
Final verdict CHANGES REQUESTED (CRITICAL=1 MEDIUM=1 MINOR=1) — reported honestly; all three findings predate this PR, whose own diff the reviewer cleared
Follow-up needed A separate ticket + PR for the XRPT archive/pruning CRITICAL and the path_find MEDIUM

Run stats — this pipeline run only (Phases 8-11)

Elapsed:         00h 35m 34s  (first→last logged activity)
Transcripts:     1 main + 6 subagent
API round-trips: 434  (main=83, subagents=351)

Fresh tokens:    input=868  output=288349  (sum=289217)
Cached tokens:   cache_read=32466470  cache_write=1522277
Total billed:    34277964 tokens

Split (total billed):  main=8028725  subagents=26249239

Models used:
  claude-sonnet-5         351 calls   26249239 billed
  claude-opus-5            83 calls   8028725 billed

These figures cover only Phases 8-11 in this workflow run — they are not a Phases 1-11 grand total. This PR was authored by hand rather than by a create_spec run, so there is no sibling Phases 1-7 run to add to them.

To redo any part of this: /rerun-probe (Phase 8 only), /rerun-review (9), /rerun-fix (10 + 10b), /rerun-final (11), or /rerun-from <8|9|10|11> to run that phase through the end of the span.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants