Try another approach from the same checkpoint.

a saved fork at rest

Storage, and only storage. A fork shares its parent chunks, so what it bills is the deduplicated bytes its own checkpoints hold. It is not consuming session time while it sits there.

a running branch

A branch you are running is a session. It bills session-minutes for as long as its machine is awake, plus the storage its checkpoints hold. The model calls it makes run on your own key and are paid to your provider directly, so KeepState adds no markup to them and never sums them into its own bill.

an attempt that fails

The same as one that succeeds. The minutes ran, the calls were made, and the checkpoints were written, so all three are billed. A losing branch is charged exactly like the winning one, and only the result differs.

where the cap sits

Budgets are enforced per session, by the gateway: a session that reaches its budget checkpoints and parks rather than overrunning. Each branch is its own session with its own budget, so a fan-out of branches is that many budgets running at once, not one budget shared between them. A pool that caps a whole lineage from its parent is designed and has no gate, so it is not a cap you can rely on today.

So three branches running at once, one of which fails, bill three sets of session-minutes for as long as each was awake, three sets of provider calls on your own key, the deduplicated storage all three hold, and nothing is deducted for the one that failed.

The rates for the two metered categories are published on the pricing page. What your provider charges for the calls is between you and your provider.