diff --git a/AGENTS.md b/AGENTS.md
index 0db4721..6ac8797 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -6,10 +6,13 @@ Orgchain is lineage's app for creating and operating lineage holdings on Super T
 - Lineage semantics live in one place, `src/orgchain/lineage.js`. The UI never interprets events itself, and every act
   is vetted by that reducer before it is signed. A new op means a reducer change, its tests and the README's table.
 - The engine (`src/adapters`, `src/upstream`, `src/storage.js`, `src/miner.js`) is Super Testnet's. Compose with it
-  rather than rewriting it, and keep its tests passing. Preserve upstream licenses and provenance. Its one local
-  change is P2WPKH payments in `src/adapters/chain.js` (PROVENANCE.md); keep it small and tested.
-- Money lives in `src/orgchain/money.js`: beats pay the holding being worked in, and sends stay inside a holding and
-  spend SegWit coins only, so an inscription can never leave as change. Balances are read off the chain, never stored.
+  rather than rewriting it, and keep its tests passing. Preserve upstream licenses and provenance. Its local
+  changes are P2WPKH payments and a coinbase split across up to 64 outputs, both in `src/adapters/chain.js`
+  (PROVENANCE.md); keep them small and tested.
+- Money lives in `src/orgchain/money.js`: beats pay the holdings (split by hashrate, or all to the last act), sends
+  spend SegWit coins only, so an inscription can never leave as change, and balances are read off the chain, never
+  stored. Gas (`src/orgchain/actions.js`): every act is paid by the actor's own keys and checked before anything is
+  signed; the lab wallet pays only for foundings and for holdings that predate lab keys.
 - Keys follow the tree (`src/orgchain/keys.js`): store roots only (one per holding, one per graduated org) and derive
   every other key from its position. Every act is signed by whichever key holds the authorizing inscription.
 - A node's chain key is its account's BIP-86 Taproot key (`m/86'/1'/account'/0/0`); SegWit is BIP-84 at the same
diff --git a/PROVENANCE.md b/PROVENANCE.md
index 2ba5c79..41702cd 100644
--- a/PROVENANCE.md
+++ b/PROVENANCE.md
@@ -20,7 +20,7 @@ Runtime dependencies are pinned in `package.json` and `package-lock.json`:
 - **@scure/bip32 1.7.0**, Patricio Palladino and Paul Miller, [upstream](https://github.com/paulmillr/scure-bip32), MIT. Used for HD derivation under the BIP-85, BIP-86, BIP-84 and NIP-06 paths. License retained at [`public/licenses/scure-bip32.txt`](public/licenses/scure-bip32.txt).
 - **@scure/bip39 1.6.0**, Patricio Palladino and Paul Miller, [upstream](https://github.com/paulmillr/scure-bip39), MIT. Used for the 24-word lab roots and their seeds. License retained at [`public/licenses/scure-bip39.txt`](public/licenses/scure-bip39.txt).
 
-One local change to the engine (Orgchain v1.5): `src/adapters/chain.js` also accepts native SegWit (P2WPKH) outputs and SIGHASH_ALL P2WPKH spends, verified per BIP-143, so lineage accounts can hold and send test BTC at their BIP-84 addresses. Everything about inscriptions stays Taproot-only. The change is original code, tested in `tests/money.test.js`; Super Testnet's tests (`tests/adapters.test.js`) pass unchanged.
+Two local changes to the engine, both original code in `src/adapters/chain.js`, tested in `tests/money.test.js`, with Super Testnet's tests (`tests/adapters.test.js`) passing unchanged. Orgchain v1.5: the chain also accepts native SegWit (P2WPKH) outputs and SIGHASH_ALL P2WPKH spends, verified per BIP-143, so lineage accounts can hold and send test BTC at their BIP-84 addresses; everything about inscriptions stays Taproot-only. Orgchain v1.6: a coinbase may split the block reward across up to 64 outputs (`mineTo`; `mine` still pays one script), so one beat can pay several holdings.
 
 Vite and Playwright are build/test dependencies, not runtime network services. Their installed package notices remain in the locked dependency installation. No unlicensed upstream code was copied.
 
diff --git a/README.md b/README.md
index dbc49f4..e6a0f2f 100644
--- a/README.md
+++ b/README.md
@@ -12,13 +12,20 @@ chain itself records who did what, and when.
 - **Time.** A beat is a block. At the default tempo each act is its own beat; at 10, 30 or 60 seconds, acts are cued and
   land together on the next beat; on manual they wait for *Beat now*. The slider and *Replay* show a holding as it
   stood at any beat.
-- **Money.** Each beat pays its 50 test BTC block reward to the holding being worked in, at the holding's SegWit
-  address (a closed holding, or one that predates lab keys, leaves it to the lab wallet). **Send** moves test BTC from
-  any active node to another in its holding, signed by the sender's BIP-84 key: at most two coins in, at most 50 test
-  BTC out, and the toy chain's fixed 500-sat fee. Sends land like acts, at once or cued, and *Beat now* mines a beat
-  even when nothing is cued. A graduation moves each re-keyed node's money to its new address along with its
-  inscription. Balances follow the slider, the timeline lists every beat's reward and every send, and Inspect has the
-  exact amounts and the raw transaction (`src/orgchain/money.js`). Inscription fees still come from the lab wallet.
+- **Money.** Test BTC lives at each node's SegWit address. **Mining** is a lab setting: under *Split* (the default)
+  every active holding mines, and each beat's 50 test BTC splits pro rata by hashrate, a dial from 0 to 9 on each
+  holding (1 unless set), one coinbase output per holding; under *Last act* the holding that acts takes the whole
+  beat, and *Beat now* pays the one being worked in. **Send** moves test BTC from any active node to any other, in
+  its holding or another, signed by the sender's BIP-84 key: at most two coins in, at most 50 test BTC out, and the
+  toy chain's fixed 500-sat fee. Sends land like acts, at once or cued, and *Beat now* mines a beat even when nothing
+  is cued. A graduation moves each re-keyed node's money to its new address along with its inscription. Balances
+  follow the slider, the timeline lists every reward, send and gas top-up, and Inspect has the exact amounts and the
+  raw transaction (`src/orgchain/money.js`).
+- **Gas.** Every act is paid by the acting node's own keys: its inscription's two fees and postage (2,000 sats),
+  plus 500 for each handoff it makes. They come out of its gas tank, the plain coins at its Taproot key, which tops
+  up from its own money 0.0001 test BTC at a time. A node with neither can't act until someone sends it money, and a
+  graduating org pays for the claim on its new root itself. The lab wallet pays only for foundings (a holding owns
+  nothing until it mines) and for holdings that predate lab keys.
 - **One interpretation.** `src/orgchain/lineage.js` folds `lineage/v0` events into trees, and vets every act before
   anything is signed. Events it rejects stay on the chain and show as rejected; they just don't change the tree.
 - **Keys.** Each holding gets its own 24-word lab root, and every node has lineage's keys at its place in the tree
@@ -38,7 +45,7 @@ chain itself records who did what, and when.
   BIP-380 checksums), and its leaves' private keys (OpenSSH, DKIM, WireGuard, PKCS#8, Headscale). Hidden again on
   every selection; lab keys only.
 
-Test coins and test keys only: a local chain, the lab wallet (the faucet that funds every key's acts) and each holding's lab
+Test coins and test keys only: a local chain, the lab wallet (the faucet that pays for foundings) and each holding's lab
 root, kept in this browser (`localStorage`, key `orgchain:lab:v1`). Nothing here is a real key; minting a real root is
 the operator's call.
 
@@ -75,8 +82,9 @@ Deploy: copy `dist/` to `ventures/lineage/orgchain/` on `teahubxyz/time` `gh-pag
 ## Built on Super Testnet
 
 The chain, wallet, inscriptions, metadata and index (`src/adapters`, `src/upstream`, with `src/storage.js` and
-`src/miner.js`) are [Super Testnet](https://supertestnet.lol)'s, with their tests (`tests/adapters.test.js`) and one
-addition: the chain also moves native SegWit (P2WPKH) payments, BIP-143 signatures included (`tests/money.test.js`).
+`src/miner.js`) are [Super Testnet](https://supertestnet.lol)'s, with their tests (`tests/adapters.test.js`) and two
+additions: the chain also moves native SegWit (P2WPKH) payments, BIP-143 signatures included, and a coinbase may
+split its reward across up to 64 outputs (`tests/money.test.js`).
 See `PROVENANCE.md` and `public/licenses/`. Lineage's key derivation and the claim and
 countersign handoff (`src/adapters/lineage-keys.js`, `src/adapters/handoff.js`, with their spec vectors in
 `tests/keys.test.js`) come from the `tree` branch. The full lab (explorer, delegates, recursion and
diff --git a/index.html b/index.html
index a1d3c70..8b8023d 100644
--- a/index.html
+++ b/index.html
@@ -16,7 +16,7 @@
     <div>
       <p class="kicker"><a href="../">Lineage</a> /</p>
       <h1 class="wordmark">Orgchain</h1>
-      <p class="lede">Found a <b>holding</b>, then birth its orgs and agents, award belts, record decisions, send test BTC, graduate and close. Each act is an inscription whose parent is the node that authorizes it, and each <b>beat</b> is a block that pays the holding 50 test BTC. Lineage gives the structure; the chain adds time.</p>
+      <p class="lede">Found a <b>holding</b>, then birth its orgs and agents, award belts, record decisions, send test BTC, graduate and close. Each act is an inscription whose parent is the node that authorizes it, paid for with the actor's own gas, and each <b>beat</b> is a block whose 50 test BTC the holdings mine. Lineage gives the structure; the chain adds time.</p>
     </div>
     <div class="flags">
       <span class="flag hz">Test coins only</span>
@@ -51,6 +51,11 @@
       <div class="panel">
         <ul class="holds" id="holdings-list"></ul>
         <div class="pad empty" id="holdings-empty"><p>A holding is the root of a lineage tree: the LLC that births orgs and agents. Found one, or load the sample, the yolopreneur tree from the Lineage docs over six beats.</p></div>
+        <div class="pad mining" id="mining">
+          <div class="mrow"><span class="lab" id="mining-l">Mining</span>
+            <div class="tempo" role="group" aria-labelledby="mining-l"><button type="button" class="seg" data-rule="split" aria-pressed="true">Split</button><button type="button" class="seg" data-rule="last" aria-pressed="false">Last act</button></div></div>
+          <p class="hint" id="mining-note"></p>
+        </div>
         <form class="pad found" id="f-found" autocomplete="off">
           <label class="lab" for="found-name">Found a holding</label>
           <div class="line"><input id="found-name" name="name" maxlength="60" spellcheck="false" placeholder="acme-holdings"><button class="btn primary" type="submit">Found</button></div>
@@ -78,6 +83,7 @@
           <div id="act-on" hidden>
             <div class="verbs" role="group" aria-label="Verb"><button type="button" data-verb="birth" aria-pressed="true">Birth</button><button type="button" data-verb="award" aria-pressed="false">Award</button><button type="button" data-verb="decide" aria-pressed="false">Decide</button><button type="button" data-verb="send" aria-pressed="false">Send</button><button type="button" data-verb="graduate" aria-pressed="false">Graduate</button><button type="button" data-verb="close" aria-pressed="false">Close</button></div>
             <p class="keyline" id="act-key"></p>
+            <p class="keyline" id="act-gas"></p>
             <p class="why pad" id="act-why"></p>
             <form class="vf pad" id="f-birth" data-form="birth" autocomplete="off">
               <p class="vh">A child of <b data-name></b>. Its birth spends <b data-name></b>'s inscription.</p>
diff --git a/src/adapters/chain.js b/src/adapters/chain.js
index a4f734b..688b633 100644
--- a/src/adapters/chain.js
+++ b/src/adapters/chain.js
@@ -14,9 +14,11 @@ const hash = value => bytesToHex(sha256(new TextEncoder().encode(JSON.stringify(
 const key = (txid, vout) => `${txid}:${vout}`;
 const scriptHex = script => Script.encode(script, false).hex;
 const assert = (condition, message) => { if (!condition) throw new Error(message); };
-// Orgchain's one addition to the engine: native SegWit (P2WPKH) outputs and SIGHASH_ALL spends (BIP-143), so lineage
-// accounts are paid at their BIP-84 addresses. Inscriptions, their parents and their handoffs stay Taproot.
+// Orgchain's two additions to the engine: native SegWit (P2WPKH) outputs and SIGHASH_ALL spends (BIP-143), so lineage
+// accounts are paid at their BIP-84 addresses, and a coinbase that may split its reward across up to MAX_PAYOUTS
+// outputs, so one beat can pay several holdings. Inscriptions, their parents and their handoffs stay Taproot.
 const TAPROOT = /^5120[0-9a-f]{64}$/, P2WPKH = /^0014[0-9a-f]{40}$/;
+export const MAX_PAYOUTS = 64;
 const hash160 = hex => bytesToHex(ripemd160(sha256(hexToBytes(hex))));
 // The BIP-143 digest commits to the spent key's P2PKH script code and the coin's value; low-S DER only.
 function segwitValid(tx, i) {
@@ -48,7 +50,7 @@ export class LocalChain {
     const tx = Tx.decode(raw), txid = Tx.util.getTxid(tx);
     assert(!this.transactions.has(txid), 'Duplicate transaction.');
     assert(tx.version === 2 && tx.locktime === 0, 'Unsupported transaction version or locktime.');
-    assert((tx.vin.length === 1 || (!coinbase && tx.vin.length === 2)) && tx.vout.length >= 1 && tx.vout.length <= 2, 'Unsupported transaction shape.');
+    assert((tx.vin.length === 1 || (!coinbase && tx.vin.length === 2)) && tx.vout.length >= 1 && tx.vout.length <= (coinbase ? MAX_PAYOUTS : 2), 'Unsupported transaction shape.');
     let total = 0;
     for (const output of tx.vout) {
       const value = Number(output.value);
@@ -62,7 +64,7 @@ export class LocalChain {
     const scriptInput = tx.vin.findIndex(i => i.witness?.length === 3);
     const input = tx.vin[scriptInput < 0 ? 0 : scriptInput];
     if (coinbase) {
-      assert(input.txid === ZERO && input.vout === 0xffffffff && tx.vout.length === 1 && total === REWARD, 'Invalid local coinbase.');
+      assert(input.txid === ZERO && input.vout === 0xffffffff && total === REWARD, 'Invalid local coinbase.');
       assert(scriptHex(input.scriptSig) === Script.encode([new TextEncoder().encode(`${NETWORK}:${height}`)], false).hex, 'Wrong coinbase height.');
       assert(!input.witness?.length, 'Unexpected coinbase witness.');
     } else {
@@ -149,13 +151,15 @@ export class LocalChain {
     catch (error) { this.utxos = utxos; this.transactions = transactions; throw error; }
     this.blocks.push(block);
   }
-  mine(script) {
+  mine(script) { return this.mineTo([getVout(REWARD, script)]); }
+  // Orgchain: the coinbase's outputs, whose values must add up to the block reward.
+  mineTo(vout) {
     // Rebuild confirmed state so pending transactions are validated in block order.
     const next = new LocalChain({ ...this.snapshot(), mempool: [] });
     const height = this.blocks.length + 1;
     const coinbase = Tx.create({
       vin: [{ txid: ZERO, vout: 0xffffffff, scriptSig: [new TextEncoder().encode(`${NETWORK}:${height}`)] }],
-      vout: [getVout(REWARD, script)],
+      vout,
     });
     const header = { height, previous: this.blocks.at(-1)?.hash ?? ZERO, time: Date.now(), raws: [Tx.encode(coinbase).hex, ...this.mempool] };
     const block = { ...header, hash: hash(header) };
diff --git a/src/main.js b/src/main.js
index 8f16bab..974b1e9 100644
--- a/src/main.js
+++ b/src/main.js
@@ -3,10 +3,10 @@
 import './orgchain.css';
 import { MetadataIndex } from './adapters/metadata-index.js';
 import { census, lineageEvents, reduce, rows, slug, summary, trail } from './orgchain/lineage.js';
-import { LAB_KEY, beat, decodeLab, emptyLab, encodeLab, mutate, readLab, setTempo, tick } from './orgchain/store.js';
-import { SAMPLE, act, minerOf, send, seedSample } from './orgchain/actions.js';
-import { addressesOf, holderOf, keyOf, leavesOf, secretsOf } from './orgchain/keys.js';
-import { DUST, balances, brief, btc, coins, ledger, most, owners, payee, payerOf, satsOf } from './orgchain/money.js';
+import { LAB_KEY, beat, decodeLab, emptyLab, encodeLab, mutate, readLab, setRigs, setRule, setTempo, tick } from './orgchain/store.js';
+import { SAMPLE, act, gasCheck, gasCost, minerOf, send, seedSample } from './orgchain/actions.js';
+import { addressesOf, derivedSubtree, holderOf, keyOf, leavesOf, secretsOf } from './orgchain/keys.js';
+import { DUST, FEE, balances, brief, btc, coins, ledger, miners, most, owners, payerOf, rigsOf, satsOf, tankOf, tanks } from './orgchain/money.js';
 import { readEnvelope } from './adapters/inscription.js';
 
 const $ = id => document.getElementById(id);
@@ -59,9 +59,9 @@ function derive() {
   if (ui.event && !live.log.some(e => e.id === ui.event)) ui.event = null;
   view = ui.beat === null ? live : reduce(events, { upTo: ui.beat });
   const owner = owners(lab.keys, events, live);
-  money = { owner, ledger: ledger(lab.chain, owner), now: balances(lab.chain, owner) };
+  money = { owner, ledger: ledger(lab.chain, owner, tanks(lab.keys, events, live)), now: balances(lab.chain, owner) };
   money.view = ui.beat === null ? money.now : balances(lab.chain, owner, ui.beat);
-  if (ui.tx && !money.ledger.some(m => m.txid === ui.tx)) ui.tx = null;
+  if (ui.tx && !money.ledger.some(m => m.key === ui.tx)) ui.tx = null;
   render();
 }
 function setBeat(value) {
@@ -94,9 +94,23 @@ async function landCue(action) {
   const acts = cuedActs(), sends = cuedSends(), height = tip();
   if (!(await run(action)) || tip() === height) return;
   const landed = [[acts - cuedActs(), 'cued act'], [sends - cuedSends(), 'cued send']].filter(([n]) => n > 0).map(([n, w]) => plural(n, w));
-  const m = money.ledger.find(x => x.kind === 'mine' && x.beat === tip()), earned = `${m ? node(m.to)?.name : 'the lab wallet'} earned ${btc(m?.amount ?? 5e9)}`;
+  const earned = earnings(money.ledger.filter(x => x.kind === 'mine' && x.beat === tip()));
   say(`Beat ${tip()}: ${landed.length ? `${landed.join(' and ')} landed, and ${earned}` : earned}.`);
 }
+// "acme earned 50 tBTC", "acme and beta earned 25 tBTC each", "acme earned 37.5 tBTC, beta 12.5 tBTC"
+function earnings(paid) {
+  if (!paid.length) return 'the lab wallet earned 50 tBTC';
+  const names = paid.map(m => node(m.to)?.name ?? '?'), amounts = paid.map(m => brief(m.amount));
+  if (paid.length === 1) return `${names[0]} earned ${btc(paid[0].amount)}`;
+  if (amounts.every(a => a === amounts[0])) return `${names.slice(0, -1).join(', ')} and ${names.at(-1)} earned ${amounts[0]} each`;
+  return paid.map((m, i) => `${names[i]}${i ? '' : ' earned'} ${amounts[i]}`).join(', ');
+}
+// Whom the next beat pays, in words.
+function paysWho() {
+  if (lab.mining?.rule === 'last') return 'the holding that acts';
+  const list = miners(lab, live);
+  return !list.length ? 'the lab wallet' : list.length === 1 ? list[0].name : `${list.length} holdings, split by hashrate`;
+}
 
 function render() { renderClock(); renderHoldings(); renderTree(); renderAct(); renderInspect(); renderTimeline(); }
 
@@ -105,9 +119,9 @@ function renderClock() {
   for (const b of document.querySelectorAll('[data-tempo]')) b.setAttribute('aria-pressed', String(String(tempo) === b.dataset.tempo));
   $('clock-beat').textContent = String(tip());
   $('clock-cued').textContent = n ? `${n} cued · ${cueNote()}` : 'nothing cued';
-  const to = payee(lab.keys, live, ui.holding) ? node(ui.holding).name : 'the lab wallet';
-  $('clock-pays').textContent = `beats pay ${to}`;
-  $('beat-now').title = `Beat now: ${n ? 'land what is cued, and ' : ''}pay ${to} 50 test BTC`;
+  const who = paysWho();
+  $('clock-pays').textContent = `beats pay ${who}`;
+  $('beat-now').title = `Beat now: ${n ? 'land what is cued, and ' : ''}pay ${who} 50 test BTC`;
 }
 function cueNote() {
   const { tempo, nextAt } = lab.clock;
@@ -117,13 +131,19 @@ function cueNote() {
 }
 
 function renderHoldings() {
+  const split = lab.mining?.rule !== 'last', mining = split ? miners(lab, live) : [], total = mining.reduce((sum, r) => sum + rigsOf(lab, r.id), 0);
   $('holdings-list').replaceChildren(...live.roots.map(r => {
-    const c = census(live, r.id), on = r.id === ui.holding;
+    const c = census(live, r.id), on = r.id === ui.holding, active = r.status === 'active', share = mining.some(x => x.id === r.id) ? rigsOf(lab, r.id) / total : 0;
     const worth = [...live.nodes.values()].reduce((sum, x) => sum + (x.root === r.id ? held(x.id) : 0), 0);
-    const facts = [at(r.born), plural(c.orgs, 'org'), plural(c.agents, 'agent'), plural(c.belts, 'belt'), worth > 0 && btc(worth), r.status === 'closed' && 'closed'].filter(Boolean);
-    return h('li', {}, h('button', { type: 'button', class: `hold${on ? ' on' : ''}${r.status === 'closed' ? ' gone' : ''}`, 'aria-pressed': String(on),
-      onclick: () => pick({ holding: r.id, node: r.id }) }, h('span', { class: 'hn', text: r.name }), ' ', h('span', { class: 'hm', text: facts.join(' · ') })));
+    const facts = [at(r.born), plural(c.orgs, 'org'), plural(c.agents, 'agent'), plural(c.belts, 'belt'), worth > 0 && brief(worth),
+      split && active && (share ? `${Math.round(share * 100)}% of each beat` : 'not mining'), !active && 'closed'].filter(Boolean);
+    return h('li', {}, h('button', { type: 'button', class: `hold${on ? ' on' : ''}${active ? '' : ' gone'}`, 'aria-pressed': String(on),
+      onclick: () => pick({ holding: r.id, node: r.id }) }, h('span', { class: 'hn', text: r.name }), ' ', h('span', { class: 'hm', text: facts.join(' · ') })),
+    split && active && payerOf(lab.keys, live, r) && rigView(r, rigsOf(lab, r.id)));
   }));
+  for (const b of document.querySelectorAll('[data-rule]')) b.setAttribute('aria-pressed', String((lab.mining?.rule ?? 'split') === b.dataset.rule));
+  $('mining-note').textContent = split ? "Every active holding mines: each beat's 50 tBTC splits by hashrate, set on each holding (0 sits out)."
+    : "The holding that acts takes the whole beat, and Beat now pays the one you're working in. Every act costs gas, so it's a race.";
   $('holdings-empty').hidden = live.roots.length > 0;
   $('holdings-sub').textContent = live.roots.length ? String(live.roots.length) : '';
   $('sample').disabled = live.roots.some(r => r.name === SAMPLE && r.status === 'active');
@@ -168,26 +188,37 @@ const derivedBelow = n => n.children.reduce((sum, id) => {
   const c = node(id);
   return c && c.edge === 'derived' && c.status === 'active' ? sum + 1 + derivedBelow(c) : sum;
 }, 0);
+// A holding's hashrate dial: 0 to 9; each beat splits by it.
+function rigView(r, n) {
+  const set = async next => { if (await run(l => setRigs(l, r.id, next))) say(next ? `${r.name} mines at hashrate ${next}.` : `${r.name} sits out of mining.`); };
+  return h('span', { class: 'rig' }, h('span', { class: 'rl', text: 'hashrate' }),
+    h('span', { class: 'rn' }, h('button', { type: 'button', class: 'rb', 'aria-label': `Lower ${r.name}'s hashrate`, disabled: n <= 0, onclick: () => set(n - 1) }, '−'),
+      h('b', { text: String(n) }), h('button', { type: 'button', class: 'rb', 'aria-label': `Raise ${r.name}'s hashrate`, disabled: n >= 9, onclick: () => set(n + 1) }, '+')));
+}
+// Who n can send to: anyone active in the lab, its own holding first, its own subtree first within that.
+const everyone = n => [...live.nodes.values()].filter(x => x.id !== n.id && x.status === 'active')
+  .map(x => [x, (x.root === n.root ? 0 : 4) + (below(x, n) ? 0 : 2) + (x.kind === 'agent' ? 0 : 1)]).sort((a, b) => a[1] - b[1]).map(([x]) => x);
 // Why n cannot send now ('' when it can).
 function sendBlock(n) {
-  const wallet = payerOf(lab.keys, live, n), root = node(n.root);
+  const wallet = payerOf(lab.keys, live, n), parent = node(n.parent);
   if (!wallet) return 'This holding predates lab keys, so it has no SegWit address to send from';
   if (most(lab.chain.coins(wallet.script)) < DUST) {
-    return n.id === n.root ? `${n.name} has no test BTC yet. Each beat pays it 50` : `${n.name} has no test BTC to send yet. Each beat pays ${root?.name ?? 'its holding'}, which can send some down`;
+    return parent ? `${n.name} has no test BTC to send yet. ${parent.name} can send some` : `${n.name} has no test BTC yet. It earns some each beat it mines`;
   }
-  return recipients(n).length ? '' : 'There is nobody else in this holding to send to yet';
+  return everyone(n).length ? '' : 'There is nobody else to send to yet';
 }
 // Why a verb is unavailable for this node ('' when it is available). The reducer has the final word.
 function blocked(n) {
   const parent = node(n.parent), closed = n.status === 'closed' ? `${n.name} is closed` : '';
+  const gas = (op, by = n.id, fields = {}) => gasCheck(lab, live, op, by, fields);
   return {
-    birth: closed || (n.kind === 'agent' ? 'Agents do not give birth' : ''),
-    award: closed || (n.kind === 'agent' ? 'Agents do not award belts' : recipients(n).length ? '' : 'There is nobody else in this holding to award yet'),
-    decide: closed,
+    birth: closed || (n.kind === 'agent' ? 'Agents do not give birth' : gas('birth')),
+    award: closed || (n.kind === 'agent' ? 'Agents do not award belts' : recipients(n).length ? gas('award') : 'There is nobody else in this holding to award yet'),
+    decide: closed || gas('decide'),
     send: closed || sendBlock(n),
     graduate: closed || (!parent ? 'A holding has no parent to graduate from' : n.kind !== 'org' ? 'Only orgs graduate'
-      : n.edge === 'adopted' ? `${n.name} has already graduated` : parent.status !== 'active' ? `${parent.name} is closed` : ''),
-    close: closed,
+      : n.edge === 'adopted' ? `${n.name} has already graduated` : parent.status !== 'active' ? `${parent.name} is closed` : gas('graduate', parent.id, { of: n.id })),
+    close: closed || gas('close'),
   };
 }
 function renderAct() {
@@ -208,8 +239,8 @@ function renderAct() {
   for (const el of document.querySelectorAll('#act-on [data-name]')) el.textContent = n.name;
   for (const el of document.querySelectorAll('#act-on [data-parent]')) el.textContent = parent?.name ?? '';
   const sig = list => list.map(o => `${o.value}=${o.textContent}`).join('|');
-  for (const to of [$('award-to'), $('send-to')]) {
-    const keep = to.value, options = recipients(n).map(x => h('option', { value: x.id, text: `${trail(live, x.id)}${x.kind === 'agent' ? ' (agent)' : ''}` }));
+  for (const [to, list] of [[$('award-to'), recipients(n)], [$('send-to'), everyone(n)]]) {
+    const keep = to.value, options = list.map(x => h('option', { value: x.id, text: `${trail(live, x.id)}${x.kind === 'agent' ? ' (agent)' : ''}` }));
     if (sig(options) !== sig([...to.options])) { to.replaceChildren(...options); if (options.some(o => o.value === keep)) to.value = keep; }
   }
   $('send-has').textContent = btc(held(n.id));
@@ -217,6 +248,9 @@ function renderAct() {
   const signer = ui.verb === 'graduate' ? parent : n, k = signer && keyOf(lab.keys, live, signer);
   const path = k && (ui.verb === 'send' ? `${k.from} · ${payerOf(lab.keys, live, signer).path}` : k.path);
   $('act-key').textContent = !signer || why[ui.verb] ? '' : k ? `Signs as ${signer.name}: ${path}` : 'Signs with the lab wallet: this holding predates lab keys.';
+  const moving = ui.verb === 'graduate' && keyOf(lab.keys, live, n) ? derivedSubtree(live, n.id).length : 0;
+  $('act-gas').textContent = !signer || why[ui.verb] || !k ? '' : ui.verb === 'send' ? `Fee: ${FEE} sats, from ${n.name}'s balance.`
+    : `Gas: ${gasCost(ui.verb, moving).toLocaleString('en-US')} sats from ${signer.name}'s tank (${btc(tankOf(lab.chain, k.wallet))}), which tops up from its balance.${moving ? ` ${n.name} pays ${FEE} more, from its own money, to claim its new root.` : ''}`;
   const below = derivedBelow(n), arming = ui.closing === n.id;
   $('close-note').textContent = below
     ? `Closing ${n.name} spends it for the last time, and its ${plural(below, 'derived descendant')} close with it. Graduated children hold their own roots and stay open.`
@@ -228,7 +262,7 @@ function renderAct() {
 function renderInspect() {
   const box = $('inspect-body'), e = ui.event ? live.log.find(x => x.id === ui.event) : null;
   if (e) { $('inspect-sub').textContent = 'event'; return box.replaceChildren(...eventView(e)); }
-  const m = ui.tx ? money.ledger.find(x => x.txid === ui.tx) : null;
+  const m = ui.tx ? money.ledger.find(x => x.key === ui.tx) : null;
   if (m) { $('inspect-sub').textContent = 'money'; return box.replaceChildren(...txView(m)); }
   const known = node(ui.node);
   $('inspect-sub').textContent = known?.kind ?? '';
@@ -247,6 +281,8 @@ function nodeView(n) {
     n.closed !== null && ['Closed', at(n.closed)],
     ['Children', n.children.length ? n.children.map(id => node(id, view)?.name).join(', ') : 'none yet'],
     payerOf(lab.keys, view, n) && ['Balance', btc(purse(n.id)), `Test BTC at its SegWit address${ui.beat === null ? '' : `, as of beat ${ui.beat}`}.`],
+    ui.beat === null && keyOf(lab.keys, live, n) && ['Gas tank', btc(tankOf(lab.chain, keyOf(lab.keys, live, n).wallet)),
+      'Plain coins at its Taproot key. Its acts burn their fees from here, and the tank tops up from its balance, 0.0001 tBTC at a time.'],
     ['Inscription', n.id],
   ].filter(Boolean);
   return [
@@ -272,13 +308,15 @@ function flow(m, id) {
   const name = x => node(x)?.name ?? '?';
   if (m.kind === 'mine') return `+${btc(m.amount)}, a beat's reward`;
   if (m.kind === 'move') return `${btc(m.amount)} moved to its new key, after a ${m.fee}-sat fee`;
+  if (m.kind === 'gas') return `−${btc(m.amount)} into its gas tank, and a ${m.fee}-sat fee`;
   return m.to === id ? `+${btc(m.amount)} from ${name(m.from)}` : `−${btc(m.amount)} to ${name(m.to)}, and a ${m.fee}-sat fee`;
 }
 // "40 tBTC yolopreneur → time"
 function moneyLine(m) {
-  const name = id => node(id)?.name ?? '?';
+  const name = id => { const x = node(id); return !x ? '?' : x.root === ui.holding ? x.name : trail(live, id); };
   if (m.kind === 'mine') return `${btc(m.amount)} → ${name(m.to)}`;
   if (m.kind === 'move') return `${btc(m.amount)} → ${name(m.to)}'s new key`;
+  if (m.kind === 'gas') return `${btc(m.amount)} → ${name(m.to)}'s gas tank`;
   return `${btc(m.amount)} ${name(m.from)} → ${name(m.to)}`;
 }
 // Lineage's keys for a node as of the viewed beat: its Taproot, SegWit and nostr addresses, where they come from, who
@@ -365,8 +403,8 @@ function txView(m) {
   const name = id => node(id)?.name ?? 'a key outside this lab', record = lab.chain.transactions.get(m.txid);
   const facts = [
     ['When', m.beat === null ? 'cued for the next beat' : `beat ${m.beat}`],
-    ['From', m.kind === 'mine' ? "the beat's block reward (its coinbase)" : `${name(m.from)}'s SegWit address${m.kind === 'move' ? ', from before it graduated' : ''}`],
-    ['To', `${name(m.to)}'s ${m.kind === 'move' ? 'new ' : ''}SegWit address`],
+    ['From', m.kind === 'mine' ? "its share of the beat's block reward (the coinbase)" : `${name(m.from)}'s SegWit address${m.kind === 'move' ? ', from before it graduated' : ''}`],
+    ['To', m.kind === 'gas' ? `${name(m.to)}'s gas tank, at its Taproot key` : `${name(m.to)}'s ${m.kind === 'move' ? 'new ' : ''}SegWit address`],
     ['Amount', btc(m.amount)],
     m.kind !== 'mine' && ['Fee', `${m.fee} sats, retired: this toy chain pays no fees to miners`],
     m.change > 0 && ['Change', `${btc(m.change)} back to ${name(m.from)}`],
@@ -411,8 +449,8 @@ function eventItem(e) {
     onclick: () => pick({ event: e.id, node: e.node ?? ui.node }) },
     h('span', { class: 'op', text: e.ok ? verb : `✕ ${verb.replace(/:$/, '')}` }), ' ', h('span', { class: 'es', text: rest.join(' ') })));
 }
-const moneyItem = m => h('li', {}, h('button', { type: 'button', class: `ev money${m.txid === ui.tx ? ' on' : ''}`, 'aria-pressed': String(m.txid === ui.tx),
-  onclick: () => pick({ tx: m.txid, node: m.to ?? ui.node }) }, h('span', { class: 'op', text: m.kind }), ' ', h('span', { class: 'es', text: moneyLine(m) })));
+const moneyItem = m => h('li', {}, h('button', { type: 'button', class: `ev money${m.kind === 'gas' ? ' gas' : ''}${m.key === ui.tx ? ' on' : ''}`, 'aria-pressed': String(m.key === ui.tx),
+  onclick: () => pick({ tx: m.key, node: node(m.to)?.root === ui.holding ? m.to : ui.node }) }, h('span', { class: 'op', text: m.kind }), ' ', h('span', { class: 'es', text: moneyLine(m) })));
 
 // Verbs
 $('f-found').addEventListener('submit', async event => {
@@ -453,7 +491,7 @@ $('f-send').addEventListener('submit', async event => {
   let txid = null;
   if (!(await run(l => { txid = send(l, n.id, to, amount); }))) return;
   const m = money.ledger.find(x => x.txid === txid);
-  say(`${n.name} sent ${btc(amount)} to ${node(to)?.name}, ${m?.beat ? `at beat ${m.beat}` : 'cued for the next beat'}.`);
+  say(`${n.name} sent ${btc(amount)} to ${node(to)?.root === n.root ? node(to).name : trail(live, to)}, ${m?.beat ? `at beat ${m.beat}` : 'cued for the next beat'}.`);
   form.elements.amount.value = '';
 });
 $('send-max').addEventListener('click', () => {
@@ -475,6 +513,12 @@ $('f-close').addEventListener('submit', async event => {
 $('close-keep').addEventListener('click', () => { ui.closing = null; renderAct(); $('close-go').focus(); });
 for (const b of document.querySelectorAll('[data-verb]')) b.addEventListener('click', () => { ui.verb = b.dataset.verb; ui.closing = null; renderAct(); });
 
+// Mining: split by hashrate, or the last act takes the beat
+for (const b of document.querySelectorAll('[data-rule]')) b.addEventListener('click', async () => {
+  const rule = b.dataset.rule;
+  if (await run(l => setRule(l, rule))) say(rule === 'split' ? 'Each beat splits across the holdings that mine, by hashrate.' : 'Each beat goes whole to the holding that acts.');
+});
+
 // Time: the tempo, Beat now, and the clock that lands cued acts when their beat is due
 for (const b of document.querySelectorAll('[data-tempo]')) b.addEventListener('click', async () => {
   const value = b.dataset.tempo, tempo = /^\d+$/.test(value) ? Number(value) : value;
diff --git a/src/orgchain.css b/src/orgchain.css
index 3445f52..654fa4f 100644
--- a/src/orgchain.css
+++ b/src/orgchain.css
@@ -297,3 +297,21 @@ textarea { resize: vertical; line-height: 1.5; }
   .v { margin-left: 1ch; }
   .mk { padding: 3px 4px 2px; }
 }
+.holds li { display: flex; align-items: stretch; }
+.holds li .hold { flex: 1 1 auto; min-width: 0; width: auto; }
+.rig { flex: none; display: grid; justify-items: center; align-content: center; gap: 4px; padding: 8px 12px; border-left: 2px solid var(--ink); }
+.holds li:has(.hold.on) .rig { background: var(--signal); color: var(--on-signal); }
+.rig .rl { font: 700 0.625rem/1 var(--mono); letter-spacing: 0.1em; text-transform: uppercase; }
+.rig .rn { display: flex; align-items: center; gap: 6px; font-weight: 700; }
+.rb { width: 26px; height: 26px; padding: 0; border: 2px solid var(--ink); border-radius: 0; background: var(--slab); color: var(--ink); font: 700 var(--t-m)/1 var(--mono); cursor: pointer; }
+.rb:hover:not(:disabled) { background: var(--concrete); }
+.rb:disabled { color: var(--ink-3); border-color: var(--ink-3); cursor: not-allowed; }
+.mining { border-top: 3px solid var(--ink); }
+.holds:empty ~ .mining { display: none; }
+.mrow { display: flex; flex-wrap: wrap; gap: 8px 12px; align-items: center; }
+.mrow .lab { margin: 0; }
+.ev.gas .op { color: var(--ink-2); font-weight: 400; }
+.holds li { display: grid; }
+.rig { display: flex; align-items: center; justify-content: space-between; gap: 10px; padding: 0 18px 12px; border-left: 0; }
+.rig .rl { color: var(--ink-2); }
+.holds li:has(.hold.on) .rig .rl { color: var(--on-signal); }
diff --git a/src/orgchain/actions.js b/src/orgchain/actions.js
index ab17f94..46fe4ad 100644
--- a/src/orgchain/actions.js
+++ b/src/orgchain/actions.js
@@ -1,7 +1,7 @@
 // Orgchain's verbs as lineage/v0 inscriptions: found, birth, award, decide, graduate, close.
 // Each act is signed by the key that holds its authorizing node's inscription (lineage's key tree, ./keys.js).
-// The lab wallet is the faucet: it funds every other key's acts and pays for handoffs. Beats pay the holding being
-// worked in (./money.js), which can send test BTC down its tree.
+// Gas: every act is paid by the acting node's own keys, topped up from its own money (./money.js); the lab wallet
+// only pays for foundings (a holding owns nothing until it mines) and for holdings that predate lab keys.
 import { Tx } from '@cmdcode/tapscript';
 import { InscriptionAdapter, POSTAGE, FEE } from '../adapters/inscription.js';
 import { MetadataIndex } from '../adapters/metadata-index.js';
@@ -12,7 +12,7 @@ import { holderCoin, makeClaim, countersign } from '../adapters/handoff.js';
 import { PROTOCOL, lineageEvents, reduce } from './lineage.js';
 import { armClock, beat } from './store.js';
 import { derivedSubtree, emptyKeys, holderOf, keyOf, rootWallet } from './keys.js';
-import { SAT, pay, payee, payerOf, sweep } from './money.js';
+import { DUST, SAT, canSpend, covers, pay, payouts, payerOf, spend, sweep } from './money.js';
 
 const FIELDS = { found: ['name'], birth: ['name', 'kind'], award: ['to', 'skill', 'belt'], decide: ['title', 'why'], graduate: ['of'], close: [] };
 const BODY = { found: m => `found ${m.name}`, birth: m => `birth ${m.name}`, award: m => `award ${m.skill} ${m.belt}`,
@@ -38,7 +38,12 @@ export function check(lab, op, by, fields) {
 }
 
 const NEED = POSTAGE + 2 * FEE + 330; // what one inscription costs a key, with dust to spare
-const GRANT = 100_000; // what the faucet gives a key that runs short: about fifty acts
+const GRANT = 100_000; // what the faucet gives a key that runs short (holdings that predate lab keys)
+const TANK = 10_000; // a gas top-up from a node's money to its acting key: a few acts' worth
+// The plain coin an act needs at its signer's key: one inscription (two fees and the postage) plus, out of its change,
+// the act's handoffs (a birth's one; a graduation's one per re-keyed descendant), with dust to spare.
+const gasFor = (op, moving = 0) => POSTAGE + 2 * FEE + (op === 'birth' ? 1 : op === 'graduate' ? Math.max(0, moving - 1) : 0) * FEE + 330;
+export const gasCost = (op, moving = 0) => gasFor(op, moving) - 330;
 const plain = (lab, wallet, min) => lab.chain.coins(wallet.script).find(c => !c.inscriptions?.length && c.value >= min);
 const vin = coin => getVin(coin.txid, coin.vout, coin.value, coin.scriptPubKey);
 const signed = (tx, signers) => { signers.forEach((wallet, i) => { tx.vin[i].witness = [wallet.sign(tx, undefined, i)]; }); return Tx.encode(tx).hex; };
@@ -49,25 +54,54 @@ export function fund(lab) {
   if (!lab.wallet) lab.wallet = TestWallet.create();
   if (!plain(lab, lab.wallet, GRANT + FEE + 330)) beat(lab);
 }
-// Give a key a plain coin when it runs short, so it can sign its own acts.
-function supply(lab, wallet, min = NEED) {
+// The lab wallet gives a key a plain coin: a founding's gas, or a key of a holding that predates lab keys.
+function supply(lab, wallet, min = NEED, amount = GRANT) {
   if (wallet === lab.wallet || plain(lab, wallet, min)) return;
-  const coin = plain(lab, lab.wallet, GRANT + FEE + 330);
-  const tx = Tx.create({ vin: [vin(coin)], vout: [getVout(GRANT, wallet.script), getVout(coin.value - GRANT - FEE, lab.wallet.script)] });
+  const coin = plain(lab, lab.wallet, amount + FEE + 330);
+  const tx = Tx.create({ vin: [vin(coin)], vout: [getVout(amount, wallet.script), getVout(coin.value - amount - FEE, lab.wallet.script)] });
   lab.chain.submitPackage([signed(tx, [lab.wallet])]);
 }
-// Move an inscription from the key that holds it to another; the faucet pays the fee.
-function hand(lab, id, from, to) {
-  const held = holderCoin(lab.chain, id), fee = plain(lab, lab.wallet, FEE + 330);
-  const tx = Tx.create({ vin: [vin(held), vin(fee)], vout: [getVout(held.value, to.script), getVout(fee.value - FEE, lab.wallet.script)] });
-  lab.chain.submitPackage([signed(tx, [from, lab.wallet])]);
+// Gas: when a node's acting key has no plain coin big enough, the node tops it up from its own money.
+function fuel(lab, state, node, wallet, min) {
+  if (wallet === lab.wallet || plain(lab, wallet, min)) return;
+  const purse = node && payerOf(lab.keys, state, node);
+  if (!purse) return supply(lab, wallet, min);
+  spend(lab, purse, wallet.script, Math.max(TANK, min), node.name);
+}
+function gasReady(lab, state, node, wallet, min) {
+  if (wallet === lab.wallet || plain(lab, wallet, min)) return true;
+  const purse = node && payerOf(lab.keys, state, node);
+  return !purse || canSpend(lab, purse, Math.max(TANK, min));
+}
+// Why an act cannot pay its gas ('' when it can), checked before anything is signed. A graduate also pays for the
+// claim on its fresh root, out of the money that moves with it.
+export function gasCheck(lab, state, op, by, fields = {}) {
+  const actor = by ? state.nodes.get(by) : null, wallet = actor && holderOf(lab, state, by)?.wallet;
+  if (op === 'found' || !wallet) return '';
+  const org = op === 'graduate' ? state.nodes.get(fields.of) : null;
+  const moving = org && keyOf(lab.keys, state, org) ? derivedSubtree(state, org.id).length : 0;
+  if (!gasReady(lab, state, actor, wallet, gasFor(op, moving))) {
+    const parent = state.nodes.get(actor.parent);
+    return parent ? `${actor.name} has no test BTC for gas. ${parent.name} can send some` : `${actor.name} has no test BTC for gas. It earns some each beat it mines`;
+  }
+  const purse = moving ? payerOf(lab.keys, state, org) : null;
+  if (purse && !covers(lab.chain.coins(purse.script).filter(c => c.value - FEE >= DUST).map(c => ({ value: c.value - FEE })), TANK)) {
+    return `${org.name} needs test BTC of its own to claim its new root. Send it some first`;
+  }
+  return '';
+}
+// Move an inscription from the key that holds it to another; payer's key pays the fee.
+function hand(lab, id, from, to, payer = from) {
+  const held = holderCoin(lab.chain, id), fee = plain(lab, payer, FEE + 330);
+  const tx = Tx.create({ vin: [vin(held), vin(fee)], vout: [getVout(held.value, to.script), getVout(fee.value - FEE, payer.script)] });
+  lab.chain.submitPackage([signed(tx, [from, payer])]);
 }
 function inscribe(lab, wallet, op, by, metadata) {
   return new InscriptionAdapter(lab.chain, wallet).inscribe(BODY[op](metadata), by ?? null, metadata, { metaprotocol: PROTOCOL });
 }
-// A beat pays the holding of the node that acted, or the lab wallet when that holding is closed or predates lab keys.
-const minerFor = (lab, id) => { const state = lineageState(lab); return payee(lab.keys, state, state.nodes.get(id)?.root ?? null); };
-export const minerOf = (lab, holdingId) => payee(lab.keys, lineageState(lab), holdingId);
+// What a beat pays (money.js payouts): every mining holding's share, or, under 'last', the holding that acted.
+const minerFor = (lab, id) => { const state = lineageState(lab); return payouts(lab, state, state.nodes.get(id)?.root ?? null); };
+export const minerOf = (lab, holdingId) => payouts(lab, lineageState(lab), holdingId);
 // Who signs for a node: whichever key holds its inscription.
 function signerFor(lab, state, id) {
   const holder = holderOf(lab, state, id);
@@ -81,15 +115,15 @@ function signerFor(lab, state, id) {
 function perform(lab, op, by, metadata) {
   if (op === 'found') {
     const mnemonic = newMnemonic(), root = rootWallet(lab.keys, mnemonic);
-    supply(lab, root);
+    supply(lab, root, NEED, NEED); // a holding owns nothing until it mines, so the lab wallet pays its founding
     const id = inscribe(lab, root, op, null, metadata);
     lab.keys.roots[id] = mnemonic;
     return id;
   }
-  const before = lineageState(lab), signer = signerFor(lab, before, by);
+  const before = lineageState(lab), signer = signerFor(lab, before, by), actor = before.nodes.get(by);
   const org = op === 'graduate' ? before.nodes.get(metadata.of) : null;
   const moving = org && keyOf(lab.keys, before, org) ? derivedSubtree(before, org.id).map(n => [n.id, signerFor(lab, before, n.id)]) : [];
-  supply(lab, signer);
+  fuel(lab, before, actor, signer, gasFor(op, moving.length));
   const id = inscribe(lab, signer, op, by, metadata);
   if (op === 'birth') {
     const after = lineageState(lab), child = keyOf(lab.keys, after, after.nodes.get(id));
@@ -102,9 +136,10 @@ function perform(lab, op, by, metadata) {
       const to = keyOf(lab.keys, after, after.nodes.get(nodeId)).wallet;
       // Its money follows it: what sits at its old SegWit address moves to its new one.
       sweep(lab, payerOf(lab.keys, before, before.nodes.get(nodeId)), payerOf(lab.keys, after, after.nodes.get(nodeId)));
-      if (nodeId !== org.id) { hand(lab, nodeId, from, to); continue; }
-      // The fresh root signs its fee input first, which fixes where the org goes; the holder then countersigns.
-      supply(lab, to, FEE + 330);
+      if (nodeId !== org.id) { hand(lab, nodeId, from, to, signer); continue; }
+      // The fresh root signs its fee input first, which fixes where the org goes; the holder then countersigns. The
+      // graduate pays that fee itself, out of the money that just moved with it.
+      fuel(lab, after, after.nodes.get(nodeId), to, FEE + 330);
       countersign(lab.chain, makeClaim(lab.chain, nodeId, to), from);
     }
   }
@@ -113,7 +148,8 @@ function perform(lab, op, by, metadata) {
 
 // One act is one inscription whose parent is the authorizing node. At the 'each' tempo it lands at once; otherwise it is cued.
 export function act(lab, op, by, fields, now = Date.now()) {
-  const metadata = check(lab, op, by, fields);
+  const metadata = check(lab, op, by, fields), why = gasCheck(lab, lineageState(lab), op, by ?? null, metadata);
+  if (why) throw new Error(`${why}.`);
   fund(lab);
   const id = perform(lab, op, by ?? null, metadata);
   if (lab.clock.tempo === 'each') beat(lab, minerFor(lab, by ?? id)); else armClock(lab, now);
@@ -128,19 +164,19 @@ export function send(lab, from, to, amount, now = Date.now()) {
 }
 
 // The drawing in docs/lineage.md, rehearsed over six beats. Names stand in for inscription ids until those exist.
-// Every beat pays yolopreneur, and a few sends pass that down the tree.
+// Its beats pay yolopreneur, and sends pass money down the tree before each org acts, since every act pays its gas.
 export const SAMPLE = 'yolopreneur';
 const PLAN = [
   [['found', null, { name: 'yolopreneur' }]],
   [['birth', 'yolopreneur', { name: 'well-known', kind: 'org' }], ['birth', 'yolopreneur', { name: 'time', kind: 'org' }]],
-  [['birth', 'well-known', { name: 'mailr', kind: 'org' }], ['birth', 'well-known', { name: 'lineage', kind: 'org' }],
-    ['birth', 'time', { name: 'luna', kind: 'agent' }], ['birth', 'time', { name: 'sol', kind: 'agent' }], ['birth', 'time', { name: 'astra', kind: 'agent' }],
-    ['send', 'yolopreneur', { to: 'time', amount: 40 }], ['send', 'yolopreneur', { to: 'well-known', amount: 10 }]],
-  [['birth', 'time', { name: 'docscope', kind: 'org' }], ['birth', 'time', { name: 'dollhouse', kind: 'org' }],
-    ['birth', 'time', { name: 'doodleloop', kind: 'org' }], ['birth', 'time', { name: 'hearthframe', kind: 'org' }],
-    ['send', 'well-known', { to: 'lineage', amount: 2 }]],
-  [['award', 'time', { to: 'sol', skill: 'launch', belt: 'green' }], ['award', 'time', { to: 'luna', skill: 'post', belt: 'white' }],
-    ['send', 'time', { to: 'sol', amount: 1 }], ['send', 'time', { to: 'luna', amount: 0.5 }],
+  [['send', 'yolopreneur', { to: 'time', amount: 40 }], ['send', 'yolopreneur', { to: 'well-known', amount: 10 }],
+    ['birth', 'well-known', { name: 'mailr', kind: 'org' }], ['birth', 'well-known', { name: 'lineage', kind: 'org' }],
+    ['birth', 'time', { name: 'luna', kind: 'agent' }], ['birth', 'time', { name: 'sol', kind: 'agent' }], ['birth', 'time', { name: 'astra', kind: 'agent' }]],
+  [['send', 'well-known', { to: 'lineage', amount: 2 }],
+    ['birth', 'time', { name: 'docscope', kind: 'org' }], ['birth', 'time', { name: 'dollhouse', kind: 'org' }],
+    ['birth', 'time', { name: 'doodleloop', kind: 'org' }], ['birth', 'time', { name: 'hearthframe', kind: 'org' }]],
+  [['send', 'time', { to: 'sol', amount: 1 }], ['send', 'time', { to: 'luna', amount: 0.5 }],
+    ['award', 'time', { to: 'sol', skill: 'launch', belt: 'green' }], ['award', 'time', { to: 'luna', skill: 'post', belt: 'white' }],
     ['decide', 'yolopreneur', { title: 'Every venture gets a page', why: '<venture>.yolopreneur.lol, served from one pages branch.' }]],
   [['graduate', 'well-known', { of: 'lineage' }],
     ['decide', 'lineage', { title: 'Lineage gets its own org', why: 'Its own repo on Teahub now, lineage.llc later: adopted, not derived.' }]],
diff --git a/src/orgchain/keys.js b/src/orgchain/keys.js
index cc61eae..5f2f3a3 100644
--- a/src/orgchain/keys.js
+++ b/src/orgchain/keys.js
@@ -42,12 +42,18 @@ export function seedOf(keys, state, node) {
   return up && { mnemonic: childMnemonic(up.mnemonic, node.index), account: 0, origin: up.origin, steps: [...up.steps, `${node.index}'`] };
 }
 
+// Deriving a chain key takes milliseconds and the UI asks often, so each account's keys are made once per page.
+const chainKeys = new Map();
 export function keyOf(keys, state, node) {
   const seed = seedOf(keys, state, node);
   if (!seed) return null;
-  const { npub, pubkey } = nostrKey(seed.mnemonic, seed.account), from = [seed.origin, ...seed.steps].join(' › ');
-  return { wallet: new TestWallet(chainSecret(keys, seed.mnemonic, seed.account)), npub, pubkey, scheme: keys.scheme,
-    account: seed.account, from, path: `${from} · ${pathAt(keys, seed.account)}` };
+  const id = `${keys.scheme}|${seed.mnemonic}|${seed.account}`;
+  if (!chainKeys.has(id)) {
+    const { npub, pubkey } = nostrKey(seed.mnemonic, seed.account);
+    chainKeys.set(id, { wallet: new TestWallet(chainSecret(keys, seed.mnemonic, seed.account)), npub, pubkey });
+  }
+  const { wallet, npub, pubkey } = chainKeys.get(id), from = [seed.origin, ...seed.steps].join(' › ');
+  return { wallet, npub, pubkey, scheme: keys.scheme, account: seed.account, from, path: `${from} · ${pathAt(keys, seed.account)}` };
 }
 
 // A node's public addresses, listed so no one has to derive them: Taproot holds its inscription and takes
diff --git a/src/orgchain/money.js b/src/orgchain/money.js
index 5efd939..7527ddf 100644
--- a/src/orgchain/money.js
+++ b/src/orgchain/money.js
@@ -1,13 +1,14 @@
-// Orgchain's money: test BTC that moves inside a holding. Each beat pays its block reward to the holding being worked
-// in, at the holding's SegWit address (BIP-84), and any active node can send to another node of its holding, signed by
-// its own SegWit key. A graduation re-keys a subtree, and its money moves to the new keys with it. Inscriptions and
-// their fees stay on Taproot, where the lab wallet still pays. Test coins only.
+// Orgchain's money: test BTC at each node's SegWit address (BIP-84). Beats pay holdings: under 'split' every active
+// holding mines a share by its hashrate, under 'last' the holding that acted takes the beat. Any active node can send
+// to any other, signed by its own SegWit key, and a graduation re-keys a subtree and moves its money along. A node's
+// acts burn gas from its acting key (Taproot), which tops up from its money (actions.js). Test coins only.
 import { Address, Signer, Tx } from '@cmdcode/tapscript';
 import { FEE } from '../adapters/inscription.js';
+import { MAX_PAYOUTS } from '../adapters/chain.js';
 import { getVin, getVout } from '../upstream/primitives.js';
 import { PATHS, segwitPubkey, segwitSecret } from '../adapters/lineage-keys.js';
 import { reduce } from './lineage.js';
-import { scriptHex, seedOf } from './keys.js';
+import { keyOf, scriptHex, seedOf } from './keys.js';
 
 export { FEE };
 export const SAT = 100_000_000;
@@ -51,11 +52,30 @@ export function payerOf(keys, state, node) {
   return wallets.get(id);
 }
 
-// Whom a beat pays: the holding being worked in, while it is active and has lab keys. Null means the lab wallet.
+// A holding's SegWit script while it is active and has lab keys, or null.
 export function payee(keys, state, holdingId) {
   const holding = holdingId ? state.nodes.get(holdingId) : null;
   return holding?.kind === 'holding' && holding.status === 'active' ? payerOf(keys, state, holding)?.script ?? null : null;
 }
+// A holding's hashrate: 0 to 9 rigs, 1 unless set.
+export const rigsOf = (lab, id) => lab.mining?.rigs?.[id] ?? 1;
+// The holdings that mine under 'split': active, keyed, with a hashrate above zero (at most MAX_PAYOUTS of them).
+export function miners(lab, state) {
+  return state.roots.filter(r => r.status === 'active' && rigsOf(lab, r.id) > 0 && payerOf(lab.keys, state, r)).slice(0, MAX_PAYOUTS);
+}
+// What a beat pays, as coinbase outputs; null means the lab wallet. Under 'split' the reward splits pro rata by
+// hashrate (the last miner takes the odd sats); under 'last' the holding that acted, or the one being worked in,
+// takes it all.
+export function payouts(lab, state, holdingId) {
+  if (lab.mining?.rule === 'last') { const script = payee(lab.keys, state, holdingId); return script ? [{ script, value: REWARD }] : null; }
+  const list = miners(lab, state), total = list.reduce((sum, r) => sum + rigsOf(lab, r.id), 0);
+  let left = REWARD;
+  return list.length ? list.map((r, i) => {
+    const value = i === list.length - 1 ? left : Math.floor((REWARD * rigsOf(lab, r.id)) / total);
+    left -= value;
+    return { script: payerOf(lab.keys, state, r).script, value };
+  }) : null;
+}
 
 // The coins a send spends: the fewest and smallest that cover the amount and the fee and leave no dust. The toy chain
 // takes at most two inputs, and no output above one block reward.
@@ -91,27 +111,33 @@ function short(name, list, amount) {
   return `One send spends at most two coins, so the most ${name} can send at once is ${btc(max)}.`;
 }
 
-// One send: the sender's coins in, the amount to the recipient's SegWit address, change back, and the fixed fee.
-export function pay(lab, state, fromId, toId, amount) {
-  const from = state.nodes.get(fromId), to = state.nodes.get(toId);
-  if (!from || !to) throw new Error('Pick who sends and who receives.');
-  if (from.id === to.id) throw new Error(`${from.name} cannot send to itself.`);
-  if (from.root !== to.root) throw new Error('Sends stay inside one holding for now.');
-  for (const n of [from, to]) if (n.status !== 'active') throw new Error(`${n.name} is ${n.status}.`);
-  const wallet = payerOf(lab.keys, state, from), dest = payerOf(lab.keys, state, to);
-  if (!wallet || !dest) throw new Error('This holding predates lab keys, so it has no SegWit addresses.');
-  if (!Number.isSafeInteger(amount) || amount < DUST) throw new Error(`Send at least ${DUST} sats.`);
-  if (amount > REWARD) throw new Error('Send at most 50 test BTC at a time: no output on this chain is bigger than one block reward.');
+// Whether these coins, or a SegWit wallet's, can pay this amount in one transaction.
+export const covers = (list, amount) => !!choose(list, amount);
+export const canSpend = (lab, wallet, amount) => covers(lab.chain.coins(wallet.script), amount);
+// Spend from a SegWit wallet: its coins in, the amount to script, change back, and the fixed fee.
+export function spend(lab, wallet, script, amount, name = 'This node') {
   const list = lab.chain.coins(wallet.script), picked = choose(list, amount);
-  if (!picked) throw new Error(short(from.name, list, amount));
+  if (!picked) throw new Error(short(name, list, amount));
   const change = picked.reduce((sum, c) => sum + c.value, 0) - amount - FEE;
   const tx = Tx.create({ vin: picked.map(c => getVin(c.txid, c.vout, c.value, c.scriptPubKey)),
-    vout: [getVout(amount, dest.script), ...(change ? [getVout(change, wallet.script)] : [])] });
+    vout: [getVout(amount, script), ...(change ? [getVout(change, wallet.script)] : [])] });
   picked.forEach((c, i) => { tx.vin[i].witness = wallet.sign(tx, i); });
   const raw = Tx.encode(tx).hex;
   lab.chain.submitPackage([raw]);
   return Tx.util.getTxid(raw);
 }
+// One send between active nodes, in one holding or across holdings: the amount to the recipient's SegWit address.
+export function pay(lab, state, fromId, toId, amount) {
+  const from = state.nodes.get(fromId), to = state.nodes.get(toId);
+  if (!from || !to) throw new Error('Pick who sends and who receives.');
+  if (from.id === to.id) throw new Error(`${from.name} cannot send to itself.`);
+  for (const n of [from, to]) if (n.status !== 'active') throw new Error(`${n.name} is ${n.status}.`);
+  const wallet = payerOf(lab.keys, state, from), dest = payerOf(lab.keys, state, to);
+  if (!wallet || !dest) throw new Error('A holding that predates lab keys has no SegWit addresses.');
+  if (!Number.isSafeInteger(amount) || amount < DUST) throw new Error(`Send at least ${DUST} sats.`);
+  if (amount > REWARD) throw new Error('Send at most 50 test BTC at a time: no output on this chain is bigger than one block reward.');
+  return spend(lab, wallet, dest.script, amount, from.name);
+}
 
 // When a graduation re-keys a node, its money follows: each coin at its old SegWit address moves to the new one,
 // less the fee. A coin too small to pay its own fee stays behind.
@@ -128,29 +154,38 @@ export function sweep(lab, from, to) {
   return moved;
 }
 
-// Every SegWit script a node has had, so beats and sends can be named at any beat. A graduation re-keys its subtree,
-// so those nodes also have the script they had before it. live must be reduce(events, { pending: true }).
-export function owners(keys, events, live) {
+// The trees a lab has had: now, and just before each graduation, which re-keys a subtree. live must be
+// reduce(events, { pending: true }), so its log lines up with events.
+const epochs = (events, live) => [live, ...live.log.flatMap((e, i) => (e.ok && e.op === 'graduate' ? [reduce(events.slice(0, i), { pending: true })] : []))];
+function scripts(states, scriptOf) {
   const map = new Map();
-  const add = state => {
-    for (const n of state.nodes.values()) {
-      const w = payerOf(keys, state, n), s = w && scriptHex(w.script);
-      if (s && !map.has(s)) map.set(s, n.id);
-    }
-  };
-  add(live);
-  live.log.forEach((e, i) => { if (e.ok && e.op === 'graduate') add(reduce(events.slice(0, i), { pending: true })); });
+  for (const state of states) {
+    for (const n of state.nodes.values()) { const s = scriptOf(state, n); if (s && !map.has(s)) map.set(s, n.id); }
+  }
   return map;
 }
+// Every SegWit script a node has had (its money), so beats and sends can be named at any beat.
+export const owners = (keys, events, live) => scripts(epochs(events, live), (state, n) => { const w = payerOf(keys, state, n); return w && scriptHex(w.script); });
+// Every Taproot key a node has acted with (its gas tank).
+const tankScripts = new Map();
+export const tanks = (keys, events, live) => scripts(epochs(events, live), (state, n) => {
+  const seed = seedOf(keys, state, n), id = seed && `${keys.scheme}|${seed.mnemonic}|${seed.account}`;
+  if (id && !tankScripts.has(id)) tankScripts.set(id, scriptHex(keyOf(keys, state, n).wallet.script));
+  return id ? tankScripts.get(id) : null;
+});
+// What a node's gas tank holds now: the plain coins at its acting key.
+export const tankOf = (chain, wallet) => chain.coins(wallet.script).filter(c => !c.inscriptions?.length).reduce((sum, c) => sum + c.value, 0);
 
-// The money's record in chain order: beats that paid a node (mine), sends between nodes (pay), and money that
-// followed a node to its new keys (move). A beat of null means cued.
-export function ledger(chain, owner) {
+// The money's record in chain order: a beat's reward to each node it paid (mine), sends (pay), top-ups of a node's own
+// gas tank (gas), and money that followed a node to its new keys (move). A beat of null means cued.
+export function ledger(chain, owner, tank = new Map()) {
   const out = [], who = script => owner.get(scriptHex(script)) ?? null, sum = list => list.reduce((s, x) => s + x.value, 0);
   for (const { txid, tx, height, coinbase } of chain.transactions.values()) {
-    const outs = tx.vout.map(o => ({ node: who(o.scriptPubKey), value: Number(o.value) }));
+    const outs = tx.vout.map(o => ({ script: scriptHex(o.scriptPubKey), node: who(o.scriptPubKey), value: Number(o.value) }));
     if (coinbase) {
-      if (outs[0].node) out.push({ kind: 'mine', txid, beat: height, from: null, to: outs[0].node, amount: outs[0].value, fee: 0, change: 0 });
+      outs.forEach((o, vout) => {
+        if (o.node) out.push({ kind: 'mine', key: `${txid}:${vout}`, txid, beat: height, from: null, to: o.node, amount: o.value, fee: 0, change: 0 });
+      });
       continue;
     }
     const ins = tx.vin.map(i => {
@@ -160,9 +195,10 @@ export function ledger(chain, owner) {
     const from = ins[0]?.node;
     if (!from || !ins.every(x => x?.node === from)) continue; // inscriptions, grants and handoffs are Taproot, not money
     const paid = outs.filter(o => o.node !== from), back = outs.filter(o => o.node === from), fee = sum(ins) - sum(outs);
-    out.push(paid.length
-      ? { kind: 'pay', txid, beat: height, from, to: paid[0].node, amount: paid[0].value, fee, change: sum(back) }
-      : { kind: 'move', txid, beat: height, from, to: from, amount: sum(back), fee, change: 0 });
+    const base = { key: txid, txid, beat: height, from, fee };
+    if (paid.length && paid.every(o => tank.get(o.script) === from)) out.push({ ...base, kind: 'gas', to: from, amount: sum(paid), change: sum(back) });
+    else if (paid.length) out.push({ ...base, kind: 'pay', to: paid[0].node, amount: paid[0].value, change: sum(back) });
+    else out.push({ ...base, kind: 'move', to: from, amount: sum(back), change: 0 });
   }
   return out;
 }
diff --git a/src/orgchain/store.js b/src/orgchain/store.js
index ec07dbe..2ac63af 100644
--- a/src/orgchain/store.js
+++ b/src/orgchain/store.js
@@ -3,6 +3,7 @@ import { LocalChain } from '../adapters/chain.js';
 import { NETWORK, TestWallet } from '../adapters/wallet.js';
 import { assertMnemonic } from '../adapters/lineage-keys.js';
 import { SCHEMES, emptyKeys } from './keys.js';
+import { getVout } from '../upstream/primitives.js';
 
 export const LAB_KEY = 'orgchain:lab:v1';
 // 'each': every act is its own beat. 10/30/60: acts are cued and land together on the next beat. 'manual': they wait for Beat now.
@@ -26,17 +27,33 @@ export function keysPreference(value) {
   if (!SCHEMES.includes(keys.scheme)) throw new Error('Invalid lab keys.');
   return keys;
 }
-export const emptyLab = () => ({ wallet: null, chain: new LocalChain(), clock: clockPreference(), keys: emptyKeys() });
+// Mining: under 'split' every active holding takes a share of each beat by its hashrate (0 to 9 rigs, 1 unless set);
+// under 'last' the holding that acted takes the whole beat (money.js payouts). Labs saved before v1.6 split.
+export const RULES = ['split', 'last'];
+export function miningPreference(value) {
+  const rule = value?.rule ?? 'split', rigs = {};
+  if (!RULES.includes(rule)) throw new Error('Invalid mining rule.');
+  for (const [id, n] of Object.entries(value?.rigs ?? {})) {
+    if (!/^[0-9a-f]{64}i0$/.test(id) || !Number.isSafeInteger(n) || n < 0 || n > 9) throw new Error('Invalid hashrate.');
+    if (n !== 1) rigs[id] = n;
+  }
+  return { rule, rigs };
+}
+export const emptyLab = () => ({ wallet: null, chain: new LocalChain(), clock: clockPreference(), keys: emptyKeys(), mining: miningPreference() });
 
 export function decodeLab(raw) {
   if (!raw) return emptyLab();
   const data = JSON.parse(raw);
   if (data?.kind !== 'orgchain-lab' || data.network !== NETWORK || data.version !== 1) throw new Error('That is not an Orgchain v1 lab.');
   return { wallet: data.wallet ? TestWallet.load(data.wallet) : null, chain: new LocalChain(data.chain), clock: clockPreference(data.clock),
-    keys: keysPreference(data.keys) };
+    keys: keysPreference(data.keys), mining: miningPreference(data.mining) };
 }
 export const encodeLab = lab => JSON.stringify({ kind: 'orgchain-lab', network: NETWORK, version: 1,
-  wallet: lab.wallet?.backup() ?? null, chain: lab.chain.snapshot(), clock: clockPreference(lab.clock), keys: keysPreference(lab.keys) });
+  wallet: lab.wallet?.backup() ?? null, chain: lab.chain.snapshot(), clock: clockPreference(lab.clock), keys: keysPreference(lab.keys),
+  mining: miningPreference(lab.mining) });
+// Set a holding's hashrate, or the mining rule.
+export function setRigs(lab, id, n) { lab.mining = miningPreference({ ...lab.mining, rigs: { ...lab.mining?.rigs, [id]: n } }); }
+export function setRule(lab, rule) { lab.mining = miningPreference({ ...lab.mining, rule }); }
 
 export const readLab = () => decodeLab(localStorage.getItem(LAB_KEY));
 export function saveLab(lab) {
@@ -56,11 +73,11 @@ export async function mutate(action, { locks = globalThis.navigator?.locks, read
   });
 }
 
-// The clock. A beat is a block; cued acts wait in the mempool for it. Its reward pays script (the holding being worked
-// in; see money.js), or the lab wallet.
-export function beat(lab, script = null) {
+// The clock. A beat is a block; cued acts wait in the mempool for it. Its reward pays outputs ([{ script, value }],
+// from money.js payouts), or the lab wallet.
+export function beat(lab, outputs = null) {
   if (!lab.wallet) lab.wallet = TestWallet.create();
-  const block = lab.chain.mine(script ?? lab.wallet.script);
+  const block = outputs?.length ? lab.chain.mineTo(outputs.map(o => getVout(o.value, o.script))) : lab.chain.mine(lab.wallet.script);
   lab.clock = clockPreference({ tempo: lab.clock.tempo, nextAt: null });
   return block;
 }
@@ -69,16 +86,16 @@ export function armClock(lab, now = Date.now()) {
   const { tempo, nextAt } = lab.clock;
   if (typeof tempo === 'number' && lab.chain.mempool.length && nextAt === null) lab.clock = { tempo, nextAt: now + tempo * 1000 };
 }
-export function setTempo(lab, tempo, now = Date.now(), script = null) {
+export function setTempo(lab, tempo, now = Date.now(), outputs = null) {
   lab.clock = clockPreference({ tempo, nextAt: null });
-  if (tempo === 'each' && lab.chain.mempool.length) beat(lab, script); else armClock(lab, now);
+  if (tempo === 'each' && lab.chain.mempool.length) beat(lab, outputs); else armClock(lab, now);
 }
 // Run on a timer, inside the lock: at most one beat, only when one is due, and never an empty one.
-export function tick(lab, now = Date.now(), script = null) {
+export function tick(lab, now = Date.now(), outputs = null) {
   const { tempo, nextAt } = lab.clock;
   if (typeof tempo !== 'number' || !lab.chain.mempool.length) return false;
   if (nextAt === null) { armClock(lab, now); return true; }
   if (now < nextAt) return false;
-  beat(lab, script);
+  beat(lab, outputs);
   return true;
 }
diff --git a/tests/keys.test.js b/tests/keys.test.js
index 1123996..10a4fa6 100644
--- a/tests/keys.test.js
+++ b/tests/keys.test.js
@@ -14,7 +14,8 @@ import { LocalChain } from '../src/adapters/chain.js';
 import { InscriptionAdapter } from '../src/adapters/inscription.js';
 import { TestWallet } from '../src/adapters/wallet.js';
 import { beat, decodeLab, emptyLab, encodeLab, keysPreference } from '../src/orgchain/store.js';
-import { act, fund, lineageState } from '../src/orgchain/actions.js';
+import { act, fund, lineageState, send } from '../src/orgchain/actions.js';
+import { SAT } from '../src/orgchain/money.js';
 import { addressesOf, descsum, keyOf, leavesOf, nsecOf, rootWallet, scriptHex, secretsOf, tapkeyOf, wif } from '../src/orgchain/keys.js';
 import { agentLeaves, agentRecords, agentSecrets, nodeLeaves, nodeRecords, nodeSecrets, sshFingerprint } from '../src/orgchain/leaves.js';
 
@@ -104,6 +105,7 @@ const key = (mnemonic, account) => `5120${new TestWallet(Tap.getSecKey(walletSec
 test('each holding has its own root, and every node holds its inscription at its Taproot address', () => {
   const lab = emptyLab();
   const root = act(lab, 'found', null, { name: 'acme' }), ops = act(lab, 'birth', root, { name: 'ops' });
+  send(lab, root, ops, SAT); // every act pays its own gas
   const bot = act(lab, 'birth', ops, { name: 'bot', kind: 'agent' }), lead = act(lab, 'birth', root, { name: 'lead', kind: 'agent' });
   const m = lab.keys.roots[root], opsSeed = childMnemonic(m, 0);
   assert.equal(m.split(' ').length, 24);
@@ -128,6 +130,7 @@ test('each holding has its own root, and every node holds its inscription at its
 test('leaves hang off the same tree: agents from their nostr secret, orgs from their seed', () => {
   const lab = emptyLab();
   const root = act(lab, 'found', null, { name: 'acme' }), ops = act(lab, 'birth', root, { name: 'ops' });
+  send(lab, root, ops, SAT);
   const bot = act(lab, 'birth', ops, { name: 'bot', kind: 'agent' });
   const opsSeed = childMnemonic(lab.keys.roots[root], 0), s = lineageState(lab), node = id => s.nodes.get(id);
   assert.deepEqual(leavesOf(lab.keys, s, node(bot)), agentRecords(agentLeaves(nostrSecret(opsSeed, 1)), 'bot@ops.acme', 'bot', 'ops.acme'));
@@ -139,6 +142,7 @@ test('leaves hang off the same tree: agents from their nostr secret, orgs from t
 test('secrets: an org shows its seed, a seat only its account, and every descriptor imports as it is', () => {
   const lab = emptyLab();
   const root = act(lab, 'found', null, { name: 'acme' }), ops = act(lab, 'birth', root, { name: 'ops' });
+  send(lab, root, ops, SAT);
   const bot = act(lab, 'birth', ops, { name: 'bot', kind: 'agent' });
   const m = lab.keys.roots[root], opsSeed = childMnemonic(m, 0), s = lineageState(lab), node = id => s.nodes.get(id);
   assert.deepEqual(secretsOf(lab.keys, s, node(root)).seed, { from: 'acme root', mnemonic: m });
@@ -157,8 +161,12 @@ test('secrets: an org shows its seed, a seat only its account, and every descrip
 test('graduation: a fresh root claims the org, the derived key countersigns, and the subtree re-keys', () => {
   const lab = emptyLab();
   const root = act(lab, 'found', null, { name: 'acme' }), studio = act(lab, 'birth', root, { name: 'studio' });
-  const kid = act(lab, 'birth', studio, { name: 'kid' }), deep = act(lab, 'birth', kid, { name: 'deep' });
+  send(lab, root, studio, 2 * SAT);
+  const kid = act(lab, 'birth', studio, { name: 'kid' });
+  send(lab, studio, kid, SAT);
+  const deep = act(lab, 'birth', kid, { name: 'deep' });
   const seat = act(lab, 'birth', studio, { name: 'seat', kind: 'agent' }), solo = act(lab, 'birth', studio, { name: 'solo' });
+  send(lab, studio, solo, 0.1 * SAT); // a graduate pays for the claim on its own root
   const old = childMnemonic(lab.keys.roots[root], 0);
   act(lab, 'graduate', studio, { of: solo }); // solo graduates first and keeps its own root through what follows
   const soloRoot = lab.keys.adopted[solo];
diff --git a/tests/lab.test.js b/tests/lab.test.js
index 12176cf..5459030 100644
--- a/tests/lab.test.js
+++ b/tests/lab.test.js
@@ -3,7 +3,8 @@ import assert from 'node:assert/strict';
 import { MetadataIndex } from '../src/adapters/metadata-index.js';
 import { lineageEvents, reduce } from '../src/orgchain/lineage.js';
 import { LAB_KEY, decodeLab, emptyLab, encodeLab, mutate, setTempo, tick } from '../src/orgchain/store.js';
-import { SAMPLE, act, seedSample } from '../src/orgchain/actions.js';
+import { SAMPLE, act, seedSample, send } from '../src/orgchain/actions.js';
+import { SAT } from '../src/orgchain/money.js';
 
 const state = (lab, options = { pending: true }) => reduce(lineageEvents(new MetadataIndex(lab.chain)), options);
 
@@ -25,6 +26,7 @@ test('a timed tempo cues acts, chains cued spends of one parent, and beats once
   const root = act(lab, 'found', null, { name: 'acme' });
   setTempo(lab, 10, 1000);
   const a = act(lab, 'birth', root, { name: 'a' }, 2000), b = act(lab, 'birth', root, { name: 'b' }, 3000);
+  send(lab, root, a, SAT, 3500); // a pays its own gas, out of money still cued
   act(lab, 'birth', a, { name: 'c', kind: 'agent' }, 4000);
   assert.deepEqual(lab.clock, { tempo: 10, nextAt: 12000 });
   assert.equal(state(lab, {}).nodes.has(a), false);
@@ -42,7 +44,7 @@ test('manual waits for a beat; switching back to each lands the cue', () => {
   setTempo(lab, 'manual');
   act(lab, 'decide', root, { title: 'Ship weekly', why: '' });
   assert.equal(tick(lab, Date.now() + 1e9), false);
-  assert.equal(lab.chain.mempool.length, 2);
+  assert.equal(lab.chain.mempool.length, 3); // a gas top-up from acme's money, then the commit and the reveal
   setTempo(lab, 'each');
   assert.equal(lab.chain.mempool.length, 0);
   assert.deepEqual(state(lab, {}).nodes.get(root).decisions.map(d => [d.title, d.why]), [['Ship weekly', '']]);
@@ -63,7 +65,9 @@ test('the reducer vets an act before anything is signed', () => {
 test('closing spends the node; derived children close with it and graduated ones stay open', () => {
   const lab = emptyLab();
   const root = act(lab, 'found', null, { name: 'acme' }), studio = act(lab, 'birth', root, { name: 'studio' });
+  send(lab, root, studio, SAT);
   const kid = act(lab, 'birth', studio, { name: 'kid' }), grad = act(lab, 'birth', studio, { name: 'grad' });
+  send(lab, studio, grad, 0.1 * SAT);
   act(lab, 'graduate', studio, { of: grad });
   const close = act(lab, 'close', studio, {});
   const s = state(lab, {});
diff --git a/tests/money.test.js b/tests/money.test.js
index 1591a74..6692899 100644
--- a/tests/money.test.js
+++ b/tests/money.test.js
@@ -7,20 +7,22 @@ import { LocalChain } from '../src/adapters/chain.js';
 import { getVin, getVout } from '../src/upstream/primitives.js';
 import { MetadataIndex } from '../src/adapters/metadata-index.js';
 import { lineageEvents, reduce } from '../src/orgchain/lineage.js';
-import { decodeLab, emptyLab, encodeLab, setTempo, tick } from '../src/orgchain/store.js';
-import { act, minerOf, seedSample, send } from '../src/orgchain/actions.js';
-import { FEE, PayWallet, REWARD, SAT, balances, brief, btc, ledger, most, owners, payerOf, satsOf } from '../src/orgchain/money.js';
+import { decodeLab, emptyLab, encodeLab, miningPreference, setRigs, setRule, setTempo, tick } from '../src/orgchain/store.js';
+import { act, gasCheck, lineageState, minerOf, seedSample, send } from '../src/orgchain/actions.js';
+import { FEE, PayWallet, REWARD, SAT, balances, brief, btc, ledger, most, owners, payerOf, satsOf, tankOf, tanks } from '../src/orgchain/money.js';
+import { keyOf } from '../src/orgchain/keys.js';
 
+const TOPUP = 10_000 + FEE; // what one gas top-up takes from a node's money
 const key = byte => { const secret = byte.repeat(32); return new PayWallet(secret, bytesToHex(secp256k1.getPublicKey(secret, true)), "m/84'/1'/0'/0/0"); };
-// A lab's money as the app sees it: who owns each SegWit script, balances now (or at a beat), and the ledger.
+// A lab's money as the app sees it: balances now (or at a beat), and the ledger as [kind, beat, from, to, amount].
 function money(lab, upTo) {
-  const events = lineageEvents(new MetadataIndex(lab.chain)), live = reduce(events, { pending: true }), owner = owners(lab.keys, events, live);
-  const named = map => Object.fromEntries([...map].map(([id, v]) => [live.nodes.get(id).name, v]));
-  return { live, owner, now: named(balances(lab.chain, owner, upTo)), log: ledger(lab.chain, owner).map(m =>
-    [m.kind, m.beat, live.nodes.get(m.from)?.name ?? null, live.nodes.get(m.to)?.name, m.amount]) };
+  const events = lineageEvents(new MetadataIndex(lab.chain)), live = reduce(events, { pending: true });
+  const owner = owners(lab.keys, events, live), name = id => live.nodes.get(id)?.name ?? null;
+  return { live, now: Object.fromEntries([...balances(lab.chain, owner, upTo)].map(([id, v]) => [name(id), v])),
+    log: ledger(lab.chain, owner, tanks(lab.keys, events, live)).map(m => [m.kind, m.beat, name(m.from), name(m.to), m.amount]) };
 }
 
-test('the toy chain mines to SegWit and moves P2WPKH spends signed by the key they pay', () => {
+test('the toy chain mines to SegWit, splits a coinbase, and moves P2WPKH spends signed by the key they pay', () => {
   const chain = new LocalChain(), a = key('11'), b = key('22');
   chain.mine(a.script);
   const [coin] = chain.coins(a.script);
@@ -38,79 +40,101 @@ test('the toy chain mines to SegWit and moves P2WPKH spends signed by the key th
   chain.mine(a.script);
   assert.equal(chain.balance(b.script), SAT);
   assert.equal(chain.balance(a.script), 2 * REWARD - SAT - FEE);
+  chain.mineTo([getVout(REWARD / 2, a.script), getVout(REWARD / 2, b.script)]);
+  assert.throws(() => chain.mineTo([getVout(REWARD, a.script), getVout(1000, b.script)]), /Invalid local coinbase/);
+  assert.equal(chain.blocks.length, 3);
   const copy = new LocalChain(chain.snapshot());
-  assert.deepEqual([copy.balance(a.script), copy.balance(b.script)], [2 * REWARD - SAT - FEE, SAT]);
+  assert.deepEqual([copy.balance(a.script), copy.balance(b.script)], [2.5 * REWARD - SAT - FEE, SAT + REWARD / 2]);
 });
 
-test('each beat pays the holding being worked in, and sends move test BTC down its tree', () => {
+test('every act pays its own gas, and an unfunded node is stopped before anything is signed', () => {
   const lab = emptyLab();
   const acme = act(lab, 'found', null, { name: 'acme' }), ops = act(lab, 'birth', acme, { name: 'ops' });
-  const bot = act(lab, 'birth', ops, { name: 'bot', kind: 'agent' });
-  assert.deepEqual(money(lab).now, { acme: 3 * REWARD }); // beats 2-4; beat 1 funded the lab wallet
-  send(lab, acme, ops, 12.5 * SAT);
-  send(lab, ops, bot, SAT);
-  assert.equal(lab.chain.blocks.length, 6);
-  assert.deepEqual(money(lab).now, { acme: 5 * REWARD - 12.5 * SAT - FEE, ops: 11.5 * SAT - FEE, bot: SAT });
-  assert.deepEqual(money(lab).log, [['mine', 2, null, 'acme', REWARD], ['mine', 3, null, 'acme', REWARD], ['mine', 4, null, 'acme', REWARD],
-    ['mine', 5, null, 'acme', REWARD], ['pay', 5, 'acme', 'ops', 12.5 * SAT], ['mine', 6, null, 'acme', REWARD], ['pay', 6, 'ops', 'bot', SAT]]);
-  assert.deepEqual(money(lab, 4).now, { acme: 3 * REWARD });
-  const s = money(lab).live, opsKey = payerOf(lab.keys, s, s.nodes.get(ops));
-  assert.match(opsKey.address, /^bcrt1q/);
-  assert.equal(opsKey.path, "m/84'/1'/0'/0/0");
-  assert.equal(most(lab.chain.coins(opsKey.script)), 11.5 * SAT - 2 * FEE);
   const before = encodeLab(lab);
-  assert.throws(() => send(lab, bot, ops, 2 * SAT), /^Error: bot has 1 tBTC, and sending 2 tBTC also costs the 500-sat fee\.$/);
-  assert.throws(() => send(lab, acme, acme, SAT), /cannot send to itself/);
-  assert.throws(() => send(lab, acme, ops, 51 * SAT), /at most 50 test BTC/);
-  assert.throws(() => send(lab, acme, ops, 100), /at least 330 sats/);
-  assert.throws(() => send(lab, ops, bot, 11.5 * SAT - 2 * FEE - 100),
-    /^Error: Sending 11\.499989 tBTC would leave 100 sats of change, under the 330-sat floor\. Send 11\.49999 tBTC, or at least 230 sats less\.$/);
+  assert.throws(() => act(lab, 'birth', ops, { name: 'bot', kind: 'agent' }), /^Error: ops has no test BTC for gas\. acme can send some\.$/);
+  assert.throws(() => act(lab, 'decide', ops, { title: 'Ship it' }), /ops has no test BTC for gas/);
   assert.equal(encodeLab(lab), before);
-  const other = act(lab, 'found', null, { name: 'other' });
-  assert.throws(() => send(lab, acme, other, SAT), /inside one holding/);
-  assert.equal(money(lab).now.other, REWARD); // its founding beat paid it
-  const copy = decodeLab(encodeLab(lab));
-  assert.deepEqual(money(copy).now, money(lab).now);
+  send(lab, acme, ops, 12.5 * SAT);
+  const bot = act(lab, 'birth', ops, { name: 'bot', kind: 'agent' });
+  send(lab, ops, bot, SAT);
+  const { now, log } = money(lab);
+  assert.deepEqual(now, { acme: 5 * REWARD - 12.5 * SAT - TOPUP - FEE, ops: 11.5 * SAT - TOPUP - FEE, bot: SAT });
+  assert.deepEqual(log.filter(([kind]) => kind !== 'mine'), [['gas', 3, 'acme', 'acme', 10_000], ['pay', 4, 'acme', 'ops', 12.5 * SAT],
+    ['gas', 5, 'ops', 'ops', 10_000], ['pay', 6, 'ops', 'bot', SAT]]);
+  const s = lineageState(lab), tank = name => tankOf(lab.chain, keyOf(lab.keys, s, [...s.nodes.values()].find(n => n.name === name)).wallet);
+  assert.deepEqual([tank('acme'), tank('ops')], [7830, 7500]); // a birth burns three fees and hands its postage to the child
+  assert.equal(gasCheck(lab, s, 'decide', bot, {}), '');
+  const opsKey = payerOf(lab.keys, s, s.nodes.get(ops));
+  assert.equal(most(lab.chain.coins(opsKey.script)), 11.5 * SAT - TOPUP - 2 * FEE);
+  assert.throws(() => send(lab, bot, ops, 2 * SAT), /^Error: bot has 1 tBTC, and sending 2 tBTC also costs the 500-sat fee\.$/);
+  assert.throws(() => send(lab, ops, bot, 11.5 * SAT - TOPUP - 2 * FEE - 100),
+    /^Error: Sending 11\.499884 tBTC would leave 100 sats of change, under the 330-sat floor\. Send 11\.499885 tBTC, or at least 230 sats less\.$/);
 });
 
-test('a timed tempo cues sends; the beat that lands them pays whoever the clock is told', () => {
+test('beats split across holdings by hashrate, or go whole to the last act', () => {
+  const lab = emptyLab();
+  const acme = act(lab, 'found', null, { name: 'acme' }), beta = act(lab, 'found', null, { name: 'beta' });
+  const mined = beat => money(lab).log.filter(([kind, b]) => kind === 'mine' && b === beat).map(([, , , to, amount]) => [to, amount]);
+  assert.deepEqual(mined(2), [['acme', REWARD]]);
+  assert.deepEqual(mined(3), [['acme', REWARD / 2], ['beta', REWARD / 2]]); // beta's founding beat already splits
+  setRigs(lab, acme, 3);
+  act(lab, 'decide', beta, { title: 'Mine more' });
+  assert.deepEqual(mined(4), [['acme', 37.5 * SAT], ['beta', 12.5 * SAT]]);
+  setRigs(lab, beta, 0);
+  act(lab, 'decide', acme, { title: 'Alone' });
+  assert.deepEqual(mined(5), [['acme', REWARD]]);
+  setRule(lab, 'last');
+  setRigs(lab, beta, 1);
+  act(lab, 'decide', beta, { title: 'Clicked' });
+  assert.deepEqual(mined(6), [['beta', REWARD]]);
+  assert.equal(minerOf(lab, acme).length, 1);
+  assert.deepEqual(decodeLab(encodeLab(lab)).mining, { rule: 'last', rigs: { [acme]: 3 } });
+  assert.throws(() => miningPreference({ rule: 'luck' }), /Invalid mining rule/);
+  assert.throws(() => miningPreference({ rigs: { [acme]: 10 } }), /Invalid hashrate/);
+  const three = emptyLab();
+  for (const name of ['a', 'b', 'c']) act(three, 'found', null, { name });
+  assert.deepEqual(money(three).log.filter(([kind, b]) => kind === 'mine' && b === 4).map(m => m[4]), [1666666666, 1666666666, 1666666668]);
+});
+
+test('sends cross holdings and cue at a timed tempo; closed nodes neither send nor receive', () => {
   const lab = emptyLab();
   const acme = act(lab, 'found', null, { name: 'acme' }), ops = act(lab, 'birth', acme, { name: 'ops' });
+  const beta = act(lab, 'found', null, { name: 'beta' });
+  send(lab, acme, beta, 2 * SAT);
+  assert.deepEqual(money(lab).log.at(-1), ['pay', 5, 'acme', 'beta', 2 * SAT]);
   setTempo(lab, 10, 1000);
-  send(lab, acme, ops, SAT, 2000);
+  send(lab, beta, ops, SAT, 2000);
   assert.deepEqual(lab.clock, { tempo: 10, nextAt: 12000 });
-  assert.deepEqual(money(lab).log.at(-1), ['pay', null, 'acme', 'ops', SAT]);
+  assert.deepEqual(money(lab).log.at(-1), ['pay', null, 'beta', 'ops', SAT]);
   assert.equal(money(lab).now.ops, SAT); // now includes what is cued
-  assert.equal(money(lab, 3).now.ops, undefined);
+  assert.equal(money(lab, 5).now.ops, undefined);
   assert.equal(tick(lab, 12000, minerOf(lab, acme)), true);
-  assert.deepEqual(money(lab).log.slice(-2), [['mine', 4, null, 'acme', REWARD], ['pay', 4, 'acme', 'ops', SAT]]); // a coinbase leads its block
+  assert.deepEqual(money(lab).log.slice(-3).map(m => m.slice(0, 4)), [['mine', 6, null, 'acme'], ['mine', 6, null, 'beta'], ['pay', 6, 'beta', 'ops']]);
   assert.equal(tick(lab, 99999, minerOf(lab, acme)), false); // nothing cued: no empty beats
-});
-
-test('closed nodes neither send nor receive, and a closed holding earns nothing', () => {
-  const lab = emptyLab();
-  const acme = act(lab, 'found', null, { name: 'acme' }), ops = act(lab, 'birth', acme, { name: 'ops' });
-  const lab2 = act(lab, 'birth', acme, { name: 'lab' });
-  send(lab, acme, ops, SAT);
+  setTempo(lab, 'each');
   act(lab, 'close', ops, {});
   assert.throws(() => send(lab, acme, ops, SAT), /ops is closed/);
-  assert.throws(() => send(lab, ops, lab2, 1000), /ops is closed/);
-  const paid = money(lab).now.acme;
-  act(lab, 'close', acme, {});
-  assert.equal(money(lab).now.acme, paid); // the beat that closed it paid the lab wallet
-  assert.equal(minerOf(lab, acme), null);
+  assert.throws(() => send(lab, ops, beta, 1000), /ops is closed/);
+  assert.throws(() => send(lab, acme, acme, SAT), /cannot send to itself/);
+  assert.throws(() => send(lab, acme, beta, 51 * SAT), /at most 50 test BTC/);
+  assert.throws(() => send(lab, acme, beta, 100), /at least 330 sats/);
+  act(lab, 'close', beta, {});
+  assert.equal(minerOf(lab, acme).length, 1); // a closed holding stops mining
 });
 
-test('graduation moves money to the new keys; the sample shows it', () => {
+test('graduation moves money to the new keys, and the graduate pays its own claim; the sample shows it', () => {
   const lab = emptyLab();
   seedSample(lab);
   const { now, log, live } = money(lab);
-  assert.deepEqual(now, { yolopreneur: 300 * SAT - 50 * SAT - 2 * FEE, 'well-known': 8 * SAT - FEE, lineage: 2 * SAT - FEE,
-    time: 38.5 * SAT - 2 * FEE, sol: SAT, luna: 0.5 * SAT });
-  assert.deepEqual(log.at(-1), ['move', 7, 'lineage', 'lineage', 2 * SAT - FEE]);
+  assert.deepEqual(now, { yolopreneur: 300 * SAT - 50 * SAT - 2 * FEE - TOPUP, 'well-known': 8 * SAT - FEE - TOPUP,
+    lineage: 2 * SAT - FEE - TOPUP, time: 38.5 * SAT - 2 * FEE - 3 * TOPUP, sol: SAT, luna: 0.5 * SAT });
+  assert.deepEqual(log.slice(-2), [['move', 7, 'lineage', 'lineage', 2 * SAT - FEE], ['gas', 7, 'lineage', 'lineage', 10_000]]);
   const lineage = [...live.nodes.values()].find(n => n.name === 'lineage');
-  assert.equal(lab.chain.balance(payerOf(lab.keys, live, lineage).script), 2 * SAT - FEE);
-  assert.deepEqual(money(lab, 5).now.lineage, 2 * SAT); // before graduating, at its derived address
+  assert.equal(lab.chain.balance(payerOf(lab.keys, live, lineage).script), 2 * SAT - FEE - TOPUP);
+  assert.equal(money(lab, 5).now.lineage, 2 * SAT); // before graduating, at its derived address
+  const solo = emptyLab();
+  const root = act(solo, 'found', null, { name: 'acme' }), kid = act(solo, 'birth', root, { name: 'kid' });
+  assert.throws(() => act(solo, 'graduate', root, { of: kid }), /^Error: kid needs test BTC of its own to claim its new root\. Send it some first\.$/);
 });
 
 test('amounts read and print as test BTC', () => {
diff --git a/tests/orgchain.spec.js b/tests/orgchain.spec.js
index 9e60a3c..8055a9b 100644
--- a/tests/orgchain.spec.js
+++ b/tests/orgchain.spec.js
@@ -19,6 +19,12 @@ async function birth(page, name, kind = 'org') {
   await page.locator(`#f-birth input[value="${kind}"]`).check();
   await submit(page, 'birth');
 }
+async function pay(page, to, amount) {
+  await verb(page, 'send');
+  await page.locator('#send-to').selectOption({ label: to });
+  await page.locator('#send-amount').fill(amount);
+  await submit(page, 'send');
+}
 const slide = (page, beat) => page.locator('#beat').evaluate((el, v) => { el.value = v; el.dispatchEvent(new Event('input', { bubbles: true })); }, String(beat));
 
 test('found a holding, then birth, award, decide, graduate and close at the default tempo', async ({ page }) => {
@@ -28,28 +34,34 @@ test('found a holding, then birth, award, decide, graduate and close at the defa
   await birth(page, 'studio');
   await expect(say(page)).toHaveText('studio is born to acme-holdings, at beat 3.');
   await row(page, 'studio').click();
+  await verb(page, 'birth');
+  await expect(page.locator('#act-why')).toHaveText('studio has no test BTC for gas. acme-holdings can send some.');
+  await row(page, 'acme-holdings').click();
+  await pay(page, 'acme-holdings / studio', '5');
+  await expect(say(page)).toHaveText('acme-holdings sent 5 tBTC to studio, at beat 4.');
+  await row(page, 'studio').click();
   await birth(page, 'bot', 'agent');
-  await expect(say(page)).toHaveText('bot is born to studio, at beat 4.');
+  await expect(say(page)).toHaveText('bot is born to studio, at beat 5.');
   await verb(page, 'award');
   await page.locator('#award-to').selectOption({ label: 'acme-holdings / studio / bot (agent)' });
   await page.locator('#award-skill').fill('launch');
   await page.locator('#award-belt').selectOption('green');
   await submit(page, 'award');
-  await expect(say(page)).toHaveText('bot holds a green belt in launch, at beat 5.');
+  await expect(say(page)).toHaveText('bot holds a green belt in launch, at beat 6.');
   await verb(page, 'decide');
   await page.locator('#decide-title').fill('Ship weekly');
   await submit(page, 'decide');
-  await expect(say(page)).toHaveText('studio decided “Ship weekly”, at beat 6.');
+  await expect(say(page)).toHaveText('studio decided “Ship weekly”, at beat 7.');
   await verb(page, 'graduate');
   await page.locator('#graduate-go').click();
-  await expect(say(page)).toHaveText('studio graduates from acme-holdings, at beat 7. Its edge is adopted now.');
+  await expect(say(page)).toHaveText('studio graduates from acme-holdings, at beat 8. Its edge is adopted now.');
   await expect(row(page, 'studio')).toContainText('graduated');
   await row(page, 'acme-holdings').click();
   await verb(page, 'close');
   await page.locator('#close-go').click();
   await expect(page.locator('#close-go')).toHaveText('Yes, close acme-holdings');
   await page.locator('#close-go').click();
-  await expect(say(page)).toHaveText('acme-holdings is closed, at beat 8.');
+  await expect(say(page)).toHaveText('acme-holdings is closed, at beat 9.');
   await expect(row(page, 'acme-holdings')).toContainText('closed');
   await expect(row(page, 'studio')).not.toContainText('closed'); // graduated: it holds its own root
   await row(page, 'bot').click();
@@ -83,57 +95,75 @@ test('a timed tempo cues acts; Beat now and the clock land them', async ({ page
   expect(problems).toEqual([]);
 });
 
-test('beats pay the holding, and test BTC moves down its tree', async ({ page }) => {
-  const problems = await open(page), inspect = page.locator('#inspect-body');
+test('beats pay the holdings, every act pays its gas, and test BTC moves across holdings', async ({ page }) => {
+  const problems = await open(page), inspect = page.locator('#inspect-body'), why = page.locator('#act-why');
   await found(page, 'acme');
   await expect(row(page, 'acme')).toContainText('50 tBTC');
   await expect(page.locator('#clock-pays')).toHaveText('beats pay acme');
   await birth(page, 'ops');
   await row(page, 'ops').click();
-  await birth(page, 'bot', 'agent');
+  await verb(page, 'birth');
+  await expect(why).toHaveText('ops has no test BTC for gas. acme can send some.');
   await verb(page, 'send');
-  await expect(page.locator('#act-why')).toHaveText('ops has no test BTC to send yet. Each beat pays acme, which can send some down.');
+  await expect(why).toHaveText('ops has no test BTC to send yet. acme can send some.');
   await row(page, 'acme').click();
   await verb(page, 'send');
-  await expect(page.locator('#send-has')).toHaveText('150 tBTC');
+  await expect(page.locator('#send-has')).toHaveText('99.999895 tBTC');
   await expect(page.locator('#act-key')).toHaveText("Signs as acme: acme root · m/84'/1'/0'/0/0");
-  await page.locator('#send-to').selectOption({ label: 'acme / ops' });
-  await page.locator('#send-amount').fill('12.5');
-  await submit(page, 'send');
-  await expect(say(page)).toHaveText('acme sent 12.5 tBTC to ops, at beat 5.');
+  await expect(page.locator('#act-gas')).toHaveText("Fee: 500 sats, from acme's balance.");
+  await pay(page, 'acme / ops', '12.5');
+  await expect(say(page)).toHaveText('acme sent 12.5 tBTC to ops, at beat 4.');
   await expect(row(page, 'ops')).toContainText('12.5 tBTC');
-  await expect(row(page, 'acme')).toContainText('≈187.5 tBTC');
   await row(page, 'ops').click();
+  await verb(page, 'birth');
+  await expect(page.locator('#act-gas')).toHaveText("Gas: 2,500 sats from ops's tank (0 tBTC), which tops up from its balance.");
+  await birth(page, 'bot', 'agent');
+  await expect(say(page)).toHaveText('bot is born to ops, at beat 5.');
+  await expect(row(page, 'ops')).toContainText('≈12.5 tBTC');
   await verb(page, 'send');
   await page.locator('#send-to').selectOption({ label: 'acme / ops / bot (agent)' });
   await page.locator('#send-max').click();
-  await expect(page.locator('#send-amount')).toHaveValue('12.499995');
+  await expect(page.locator('#send-amount')).toHaveValue('12.49989');
   await page.locator('#send-amount').fill('1');
   await submit(page, 'send');
   await expect(say(page)).toHaveText('ops sent 1 tBTC to bot, at beat 6.');
   await expect(row(page, 'bot')).toContainText('1 tBTC');
   await page.locator('#timeline-list .ev', { hasText: 'ops → bot' }).click();
-  for (const text of ['500 sats, retired', '11.499995 tBTC back to ops', "ops's SegWit key (BIP-143, SIGHASH_ALL)"]) await expect(inspect).toContainText(text);
+  for (const text of ['500 sats, retired', '11.49989 tBTC back to ops', "ops's SegWit key (BIP-143, SIGHASH_ALL)"]) await expect(inspect).toContainText(text);
+  await page.locator('#timeline-list .ev', { hasText: "ops's gas tank" }).click();
+  await expect(inspect).toContainText("ops's gas tank, at its Taproot key");
   await page.locator('#beat-now').click();
   await expect(say(page)).toHaveText('Beat 7: acme earned 50 tBTC.');
+  await found(page, 'beta');
+  await expect(say(page)).toHaveText('beta is founded, at beat 8.');
+  await expect(page.locator('#clock-pays')).toHaveText('beats pay 2 holdings, split by hashrate');
+  await expect(page.locator('#holdings-list')).toContainText('50% of each beat');
+  await page.getByRole('button', { name: "Raise acme's hashrate" }).click();
+  await expect(page.locator('#holdings-list')).toContainText('67% of each beat');
+  await page.locator('#beat-now').click();
+  await expect(say(page)).toHaveText('Beat 9: acme earned ≈33.33 tBTC, beta ≈16.67 tBTC.');
+  await page.locator('[data-rule="last"]').click();
+  await expect(page.locator('#clock-pays')).toHaveText('beats pay the holding that acts');
+  await page.locator('#beat-now').click();
+  await expect(say(page)).toHaveText('Beat 10: beta earned 50 tBTC.');
+  await pay(page, 'acme / ops', '2');
+  await expect(say(page)).toHaveText('beta sent 2 tBTC to acme / ops, at beat 11.');
+  await page.locator('#holdings-list .hold', { hasText: 'acme' }).click();
+  await expect(row(page, 'ops')).toContainText('≈13.5 tBTC');
+  await expect(page.locator('#timeline-list')).toContainText('2 tBTC beta → ops');
   await page.locator('[data-tempo="manual"]').click();
-  await row(page, 'acme').click();
-  await verb(page, 'send');
-  await page.locator('#send-to').selectOption({ label: 'acme / ops / bot (agent)' });
-  await page.locator('#send-amount').fill('0.25');
-  await submit(page, 'send');
+  await pay(page, 'acme / ops / bot (agent)', '0.25');
   await expect(say(page)).toHaveText('acme sent 0.25 tBTC to bot, cued for the next beat.');
   await expect(page.locator('#clock-cued')).toHaveText('1 cued · waiting for Beat now');
   await page.locator('#beat-now').click();
-  await expect(say(page)).toHaveText('Beat 8: 1 cued send landed, and acme earned 50 tBTC.');
+  await expect(say(page)).toHaveText('Beat 12: 1 cued send landed, and acme earned 50 tBTC.');
   await expect(row(page, 'bot')).toContainText('1.25 tBTC');
-  await slide(page, 4);
+  await slide(page, 3);
   await expect(row(page, 'ops')).not.toContainText('tBTC');
-  await expect(row(page, 'acme')).toContainText('150 tBTC');
+  await expect(row(page, 'acme')).toContainText('≈100 tBTC');
   await row(page, 'acme').click();
-  await expect(inspect).toContainText('as of beat 4');
+  await expect(inspect).toContainText('as of beat 3');
   await page.locator('#to-now').click();
-  await expect(page.locator('#holdings-list')).toContainText('tBTC');
   expect(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth)).toBe(true);
   expect(problems).toEqual([]);
 });