@cogcoin/client 0.5.14 → 1.0.0

package/dist/wallet/mining/runner.js

@@ -1,29 +1,29 @@
 import { createHash, randomBytes } from "node:crypto";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { lookupDomain, lookupDomainById, } from "@cogcoin/indexer/queries";
+import { getBalance, getBlockWinners, lookupDomain, lookupDomainById, } from "@cogcoin/indexer/queries";
 import { assaySentences, deriveBlendSeed, displayToInternalBlockhash, getWords, settleBlock, } from "@cogcoin/scoring";
 import { probeIndexerDaemon } from "../../bitcoind/indexer-daemon.js";
+import { FOLLOW_VISIBLE_PRIOR_BLOCKS } from "../../bitcoind/client/follow-block-times.js";
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { COG_OPCODES, COG_PREFIX } from "../cogop/constants.js";
 import { extractOpReturnPayloadFromScriptHex } from "../tx/register.js";
-import { DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB, assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, buildWalletMutationTransaction, outpointKey as walletMutationOutpointKey, isAlreadyAcceptedError, isBroadcastUnknownError, reconcilePersistentPolicyLocks, saveWalletStatePreservingUnlock, } from "../tx/common.js";
+import { assertFixedInputPrefixMatches, buildWalletMutationTransaction, outpointKey as walletMutationOutpointKey, isAlreadyAcceptedError, isBroadcastUnknownError, reconcilePersistentPolicyLocks, resolveWalletMutationFeeSelection, saveWalletStatePreservingUnlock, } from "../tx/common.js";
 import { acquireFileLock } from "../fs/lock.js";
-import { loadOrAutoUnlockWalletState } from "../lifecycle.js";
 import { isMineableWalletDomain, openWalletReadContext, } from "../read/index.js";
 import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeMine } from "../cogop/index.js";
 import { appendMiningEvent, loadMiningRuntimeStatus, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
 import { loadClientConfig } from "./config.js";
-import { MINING_HOOK_COOLDOWN_MS, MINING_HOOK_FAILURE_THRESHOLD, MINING_LOOP_INTERVAL_MS, MINING_NETWORK_SETTLE_WINDOW_MS, MINING_PROVIDER_BACKOFF_BASE_MS, MINING_PROVIDER_BACKOFF_MAX_MS, MINING_SHUTDOWN_GRACE_MS, MINING_STATUS_HEARTBEAT_INTERVAL_MS, MINING_SUSPEND_GAP_THRESHOLD_MS, MINING_TIP_SETTLE_WINDOW_MS, MINING_WORKER_API_VERSION, } from "./constants.js";
+import { MINING_LOOP_INTERVAL_MS, MINING_NETWORK_SETTLE_WINDOW_MS, MINING_PROVIDER_BACKOFF_BASE_MS, MINING_PROVIDER_BACKOFF_MAX_MS, MINING_SHUTDOWN_GRACE_MS, MINING_STATUS_HEARTBEAT_INTERVAL_MS, MINING_SUSPEND_GAP_THRESHOLD_MS, MINING_TIP_SETTLE_WINDOW_MS, MINING_WORKER_API_VERSION, } from "./constants.js";
 import { inspectMiningControlPlane, setupBuiltInMining } from "./control.js";
 import { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
-import { clearMiningFamilyState, miningFamilyMayStillExist, normalizeMiningPublishState, normalizeMiningStateRecord, } from "./state.js";
-import { createGenerateSentencesHookLimits } from "./hook-protocol.js";
+import { clearMiningPublishState, miningPublishIsInMempool, miningPublishMayStillExist, normalizeMiningPublishState, normalizeMiningStateRecord, } from "./state.js";
+import { createMiningSentenceRequestLimits } from "./sentence-protocol.js";
 import { generateMiningSentences, MiningProviderRequestError } from "./sentences.js";
-import { MiningFollowVisualizer } from "./visualizer.js";
+import { createEmptyMiningFollowVisualizerState, MiningFollowVisualizer, } from "./visualizer.js";
 const BEST_BLOCK_POLL_INTERVAL_MS = 500;
 const BACKGROUND_START_TIMEOUT_MS = 15_000;
 class MiningSuspendDetectedError extends Error {
@@ -33,6 +33,14 @@ class MiningSuspendDetectedError extends Error {
         this.detectedAtUnixMs = detectedAtUnixMs;
     }
 }
+class MiningPublishRejectedError extends Error {
+    revertedState;
+    constructor(message, revertedState) {
+        super(message);
+        this.name = "MiningPublishRejectedError";
+        this.revertedState = revertedState;
+    }
+}
 const miningGateCache = new Map();
 function createMiningSuspendDetector(monotonicNow = performance.now()) {
     return {
@@ -116,11 +124,7 @@ function cloneMiningState(state) {
     };
 }
 function hasBlockingMutation(state) {
-    return state.proactiveFamilies.some((family) => family.status === "draft"
-        || family.status === "broadcasting"
-        || family.status === "broadcast-unknown"
-        || family.status === "live"
-        || family.status === "repair-required") || (state.pendingMutations ?? []).some((mutation) => mutation.status === "draft"
+    return (state.pendingMutations ?? []).some((mutation) => mutation.status === "draft"
         || mutation.status === "broadcasting"
         || mutation.status === "broadcast-unknown"
         || mutation.status === "live"
@@ -174,6 +178,197 @@ function numberToSats(value) {
 function satsToBtc(value) {
     return Number(value) / 100_000_000;
 }
+function compareLexicographically(left, right) {
+    const length = Math.min(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        if (left[index] !== right[index]) {
+            return left[index] < right[index] ? -1 : 1;
+        }
+    }
+    if (left.length === right.length) {
+        return 0;
+    }
+    return left.length < right.length ? -1 : 1;
+}
+function tieBreakHash(blendSeed, miningDomainId) {
+    return createHash("sha256")
+        .update(Buffer.from(blendSeed))
+        .update(uint32BigEndian(miningDomainId))
+        .digest();
+}
+function createMiningLoopState() {
+    return {
+        attemptedTipKey: null,
+        currentTipKey: null,
+        selectedCandidateTipKey: null,
+        selectedCandidate: null,
+        ui: createEmptyMiningFollowVisualizerState(),
+        waitingNote: null,
+    };
+}
+export function createMiningLoopStateForTesting() {
+    return createMiningLoopState();
+}
+function buildMiningTipKey(bestBlockHash, targetBlockHeight) {
+    if (bestBlockHash === null || targetBlockHeight === null) {
+        return null;
+    }
+    return `${bestBlockHash}:${targetBlockHeight}`;
+}
+function resetMiningUiForTip(loopState, targetBlockHeight) {
+    const preservedTxid = loopState.ui.latestTxid;
+    loopState.ui = {
+        ...createEmptyMiningFollowVisualizerState(),
+        latestTxid: preservedTxid,
+    };
+    loopState.selectedCandidateTipKey = null;
+    loopState.selectedCandidate = null;
+    loopState.waitingNote = null;
+}
+export function resetMiningUiForTipForTesting(loopState, targetBlockHeight) {
+    resetMiningUiForTip(loopState, targetBlockHeight);
+}
+function fallbackSettledWinnerDomainName(domainId) {
+    return `domain-${domainId}`;
+}
+function resolveCurrentMinedBlockBoard(options) {
+    const settledBlockHeight = options.nodeBestHeight ?? options.snapshotTipHeight ?? null;
+    if (settledBlockHeight === null) {
+        return {
+            settledBlockHeight,
+            settledBoardEntries: [],
+        };
+    }
+    if (options.snapshotState === null || options.snapshotState === undefined) {
+        return {
+            settledBlockHeight,
+            settledBoardEntries: [],
+        };
+    }
+    if (options.nodeBestHeight !== null && (options.snapshotTipHeight ?? -1) < options.nodeBestHeight) {
+        return {
+            settledBlockHeight,
+            settledBoardEntries: [],
+        };
+    }
+    const settledBoardEntries = (getBlockWinners(options.snapshotState, settledBlockHeight) ?? [])
+        .slice()
+        .sort((left, right) => left.rank - right.rank || left.txIndex - right.txIndex)
+        .slice(0, 5)
+        .map((winner) => ({
+        rank: winner.rank,
+        domainName: lookupDomainById(options.snapshotState, winner.domainId)?.name ?? fallbackSettledWinnerDomainName(winner.domainId),
+        sentence: winner.sentenceText ?? "[unavailable]",
+    }));
+    return {
+        settledBlockHeight,
+        settledBoardEntries,
+    };
+}
+export function resolveSettledBoardForTesting(options) {
+    return resolveCurrentMinedBlockBoard(options);
+}
+function syncMiningUiSettledBoard(loopState, snapshotState, snapshotTipHeight, nodeBestHeight) {
+    const settledBoard = resolveCurrentMinedBlockBoard({
+        snapshotState,
+        snapshotTipHeight,
+        nodeBestHeight,
+    });
+    loopState.ui.settledBlockHeight = settledBoard.settledBlockHeight;
+    loopState.ui.settledBoardEntries = settledBoard.settledBoardEntries;
+}
+function setMiningUiCandidate(loopState, candidate) {
+    loopState.ui.latestSentence = candidate.sentence;
+    loopState.ui.provisionalRequiredWords = [...candidate.bip39Words];
+    loopState.ui.provisionalEntry = {
+        domainName: candidate.domainName,
+        sentence: candidate.sentence,
+    };
+}
+function getSelectedCandidateForTip(loopState, tipKey) {
+    if (tipKey === null || loopState.selectedCandidateTipKey !== tipKey) {
+        return null;
+    }
+    return loopState.selectedCandidate;
+}
+export function getSelectedCandidateForTipForTesting(loopState, tipKey) {
+    return getSelectedCandidateForTip(loopState, tipKey);
+}
+function cacheSelectedCandidateForTip(loopState, tipKey, candidate) {
+    loopState.selectedCandidateTipKey = tipKey;
+    loopState.selectedCandidate = candidate;
+    setMiningUiCandidate(loopState, candidate);
+}
+export function cacheSelectedCandidateForTipForTesting(loopState, tipKey, candidate) {
+    cacheSelectedCandidateForTip(loopState, tipKey, candidate);
+}
+function clearSelectedCandidate(loopState) {
+    loopState.selectedCandidateTipKey = null;
+    loopState.selectedCandidate = null;
+}
+async function resolveFundingDisplaySats(state, rpc) {
+    const utxos = await rpc.listUnspent(state.managedCoreWallet.walletName, 0);
+    return utxos.reduce((sum, entry) => {
+        if (entry.scriptPubKey !== state.funding.scriptPubKeyHex
+            || entry.spendable === false) {
+            return sum;
+        }
+        return sum + numberToSats(entry.amount);
+    }, 0n);
+}
+export async function resolveFundingDisplaySatsForTesting(state, rpc) {
+    return resolveFundingDisplaySats(state, rpc);
+}
+async function loadMiningVisibleFollowBlockTimes(options) {
+    if (options.indexedTipHeight === null || options.indexedTipHashHex === null) {
+        return {};
+    }
+    const blockTimesByHeight = {};
+    let currentHeight = options.indexedTipHeight;
+    let currentHashHex = options.indexedTipHashHex;
+    for (let offset = 0; offset <= FOLLOW_VISIBLE_PRIOR_BLOCKS; offset += 1) {
+        if (currentHeight < 0 || currentHashHex === null) {
+            break;
+        }
+        const block = await options.rpc.getBlock(currentHashHex);
+        if (typeof block.time === "number") {
+            blockTimesByHeight[currentHeight] = block.time;
+        }
+        currentHashHex = block.previousblockhash ?? null;
+        currentHeight -= 1;
+    }
+    return blockTimesByHeight;
+}
+export async function loadMiningVisibleFollowBlockTimesForTesting(options) {
+    return loadMiningVisibleFollowBlockTimes(options);
+}
+function syncMiningVisualizerBalances(loopState, readContext, balanceSats) {
+    loopState.ui.balanceCogtoshi = readContext.snapshot === null
+        ? null
+        : getBalance(readContext.snapshot.state, readContext.localState.state.funding.scriptPubKeyHex);
+    loopState.ui.balanceSats = balanceSats;
+}
+function syncMiningVisualizerBlockTimes(loopState, blockTimesByHeight) {
+    loopState.ui.visibleBlockTimesByHeight = { ...blockTimesByHeight };
+}
+export function syncMiningVisualizerBlockTimesForTesting(loopState, blockTimesByHeight) {
+    syncMiningVisualizerBlockTimes(loopState, blockTimesByHeight);
+}
+function findRecentMiningWin(snapshotState, txid, targetBlockHeight) {
+    if (snapshotState === null || snapshotState === undefined || txid === null || targetBlockHeight === null) {
+        return null;
+    }
+    const winners = getBlockWinners(snapshotState, targetBlockHeight) ?? [];
+    const winner = winners.find((entry) => entry.txidHex === txid) ?? null;
+    if (winner === null) {
+        return null;
+    }
+    return {
+        rank: winner.rank,
+        rewardCogtoshi: winner.rewardCogtoshi,
+        blockHeight: winner.height,
+    };
+}
 function computeIntentFingerprint(state, candidate) {
     return createHash("sha256")
         .update([
@@ -465,7 +660,7 @@ function buildStatusSnapshot(view, overrides = {}) {
         lastCompetitivenessGateAtUnixMs: overrides.lastCompetitivenessGateAtUnixMs ?? view.runtime.lastCompetitivenessGateAtUnixMs,
         lastError: overrides.lastError ?? view.runtime.lastError,
         note: overrides.note ?? view.runtime.note,
-        liveMiningFamilyInMempool: overrides.liveMiningFamilyInMempool ?? view.runtime.liveMiningFamilyInMempool,
+        livePublishInMempool: overrides.livePublishInMempool ?? view.runtime.livePublishInMempool,
         updatedAtUnixMs: Date.now(),
     };
 }
@@ -481,7 +676,7 @@ async function refreshAndSaveStatus(options) {
     });
     const snapshot = buildStatusSnapshot(view, options.overrides);
     await saveMiningRuntimeStatus(options.paths.miningStatusPath, snapshot);
-    options.visualizer?.update(snapshot);
+    options.visualizer?.update(snapshot, options.visualizerState);
     return snapshot;
 }
 async function appendEvent(paths, event) {
@@ -576,7 +771,9 @@ function createMiningPlan(options) {
         && entry.confirmations >= 1
         && entry.spendable !== false
         && entry.safe !== false
-        && !(entry.txid === options.conflictOutpoint.txid && entry.vout === options.conflictOutpoint.vout));
+        && !(options.conflictOutpoint !== null
+            && entry.txid === options.conflictOutpoint.txid
+            && entry.vout === options.conflictOutpoint.vout));
     const opReturnData = serializeMine(options.candidate.domainId, options.candidate.referencedBlockHashInternal, options.candidate.encodedSentenceBytes).opReturnData;
     const expectedOpReturnScriptHex = Buffer.concat([
         Buffer.from([0x6a, opReturnData.length]),
@@ -584,19 +781,11 @@ function createMiningPlan(options) {
     ]).toString("hex");
     return {
         sender: options.candidate.sender,
-        fixedInputs: [
-            options.candidate.anchorOutpoint,
-            options.conflictOutpoint,
-        ],
-        outputs: [
-            { data: Buffer.from(opReturnData).toString("hex") },
-            { [options.candidate.sender.address]: satsToBtc(BigInt(options.state.anchorValueSats)) },
-        ],
+        fixedInputs: options.conflictOutpoint === null ? [] : [options.conflictOutpoint],
+        outputs: [{ data: Buffer.from(opReturnData).toString("hex") }],
         changeAddress: options.state.funding.address,
-        changePosition: 2,
+        changePosition: 1,
         expectedOpReturnScriptHex,
-        expectedAnchorScriptHex: options.candidate.sender.scriptPubKeyHex,
-        expectedAnchorValueSats: BigInt(options.state.anchorValueSats),
         allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
         eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => walletMutationOutpointKey({ txid: entry.txid, vout: entry.vout }))),
         expectedConflictOutpoint: options.conflictOutpoint,
@@ -606,34 +795,18 @@ function createMiningPlan(options) {
 function validateMiningDraft(decoded, funded, plan) {
     const inputs = decoded.tx.vin;
     const outputs = decoded.tx.vout;
-    if (inputs.length < 2) {
+    if (inputs.length === 0) {
         throw new Error("wallet_mining_missing_inputs");
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, "wallet_mining_missing_inputs");
-    if (inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
-        throw new Error("wallet_mining_sender_input_mismatch");
-    }
-    if (inputs[1]?.prevout?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex
-        || inputs[1]?.txid !== plan.expectedConflictOutpoint.txid
-        || inputs[1].vout !== plan.expectedConflictOutpoint.vout) {
+    if (plan.expectedConflictOutpoint !== null
+        && (inputs[0]?.txid !== plan.expectedConflictOutpoint.txid
+            || inputs[0]?.vout !== plan.expectedConflictOutpoint.vout)) {
         throw new Error("wallet_mining_conflict_input_mismatch");
     }
-    assertFundingInputsAfterFixedPrefix({
-        inputs,
-        fixedInputs: plan.fixedInputs,
-        allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
-        eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
-        errorCode: "wallet_mining_unexpected_funding_input",
-    });
     if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
         throw new Error("wallet_mining_opreturn_mismatch");
     }
-    if (outputs[1]?.scriptPubKey?.hex !== plan.expectedAnchorScriptHex) {
-        throw new Error("wallet_mining_anchor_output_mismatch");
-    }
-    if (numberToSats(outputs[1]?.value ?? 0) !== plan.expectedAnchorValueSats) {
-        throw new Error("wallet_mining_anchor_value_mismatch");
-    }
     if (funded.changepos !== -1 && (funded.changepos !== plan.changePosition || outputs[funded.changepos]?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex)) {
         throw new Error("wallet_mining_change_output_mismatch");
     }
@@ -650,6 +823,12 @@ async function buildMiningTransaction(options) {
         feeRate: options.plan.feeRateSatVb,
     });
 }
+export function createMiningPlanForTesting(options) {
+    return createMiningPlan(options);
+}
+export function validateMiningDraftForTesting(decoded, funded, plan) {
+    validateMiningDraft(decoded, funded, plan);
+}
 function resolveEligibleAnchoredRoots(context) {
     const state = context.localState.state;
     const model = context.model;
@@ -662,15 +841,11 @@ function resolveEligibleAnchoredRoots(context) {
         if (!isMineableWalletDomain(context, domain)) {
             continue;
         }
-        const localRecord = state.domains.find((entry) => entry.name === domain.name);
-        const ownerIdentity = model.identities.find((identity) => identity.index === domain.ownerLocalIndex);
         const domainId = domain.domainId;
         if (domainId === null
             || domainId === undefined
-            || localRecord?.currentCanonicalAnchorOutpoint === null
-            || localRecord?.currentCanonicalAnchorOutpoint === undefined
-            || ownerIdentity?.address == null
-            || ownerIdentity.readOnly) {
+            || domain.ownerAddress == null
+            || domain.ownerScriptPubKeyHex !== model.walletScriptPubKeyHex) {
             continue;
         }
         const chainDomain = lookupDomain(snapshot.state, domain.name);
@@ -680,60 +855,47 @@ function resolveEligibleAnchoredRoots(context) {
         domains.push({
             domainId,
             domainName: domain.name,
-            localIndex: ownerIdentity.index,
+            localIndex: 0,
             sender: {
-                localIndex: ownerIdentity.index,
-                scriptPubKeyHex: ownerIdentity.scriptPubKeyHex,
-                address: ownerIdentity.address,
-            },
-            anchorOutpoint: {
-                txid: localRecord.currentCanonicalAnchorOutpoint.txid,
-                vout: localRecord.currentCanonicalAnchorOutpoint.vout,
+                localIndex: 0,
+                scriptPubKeyHex: model.walletScriptPubKeyHex,
+                address: domain.ownerAddress,
             },
         });
     }
     return domains.sort((left, right) => left.domainId - right.domainId || left.domainName.localeCompare(right.domainName));
 }
-async function persistCustomHookRuntimeOutcome(options) {
-    const hookState = options.readContext.localState.state.hookClientState.mining;
-    if (hookState.mode !== "custom") {
-        return false;
-    }
-    if (options.success) {
-        if ((hookState.consecutiveFailureCount ?? 0) === 0 && hookState.cooldownUntilUnixMs === null) {
-            return false;
-        }
-        options.readContext.localState.state.hookClientState.mining = {
-            ...hookState,
-            consecutiveFailureCount: 0,
-            cooldownUntilUnixMs: null,
-        };
-        await saveWalletStatePreservingUnlock({
-            state: options.readContext.localState.state,
-            provider: options.provider,
-            unlockUntilUnixMs: options.readContext.localState.unlockUntilUnixMs,
-            nowUnixMs: options.nowUnixMs,
-            paths: options.paths,
-        });
-        return false;
+function refreshMiningCandidateFromCurrentState(context, candidate) {
+    const refreshed = resolveEligibleAnchoredRoots(context).find((domain) => domain.domainId === candidate.domainId);
+    if (refreshed === undefined) {
+        return null;
     }
-    const consecutiveFailureCount = (hookState.consecutiveFailureCount ?? 0) + 1;
-    const cooldownUntilUnixMs = consecutiveFailureCount >= MINING_HOOK_FAILURE_THRESHOLD
-        ? options.nowUnixMs + MINING_HOOK_COOLDOWN_MS
-        : null;
-    options.readContext.localState.state.hookClientState.mining = {
-        ...hookState,
-        consecutiveFailureCount,
-        cooldownUntilUnixMs,
+    return {
+        ...candidate,
+        domainName: refreshed.domainName,
+        localIndex: refreshed.localIndex,
+        sender: refreshed.sender,
     };
-    await saveWalletStatePreservingUnlock({
-        state: options.readContext.localState.state,
-        provider: options.provider,
-        unlockUntilUnixMs: options.readContext.localState.unlockUntilUnixMs,
-        nowUnixMs: options.nowUnixMs,
-        paths: options.paths,
-    });
-    return cooldownUntilUnixMs !== null && cooldownUntilUnixMs > options.nowUnixMs;
+}
+export function refreshMiningCandidateFromCurrentStateForTesting(context, candidate) {
+    return refreshMiningCandidateFromCurrentState(context, candidate);
+}
+function resolveMiningConflictOutpoint(options) {
+    const normalizedMiningState = normalizeMiningStateRecord(options.state.miningState);
+    if (miningPublishIsInMempool(normalizedMiningState) && normalizedMiningState.sharedMiningConflictOutpoint !== null) {
+        return { ...normalizedMiningState.sharedMiningConflictOutpoint };
+    }
+    void options.allUtxos;
+    return null;
+}
+export function resolveMiningConflictOutpointForTesting(options) {
+    return resolveMiningConflictOutpoint(options);
+}
+function createStaleMiningCandidateWaitingNote() {
+    return "Mining candidate changed before broadcast: the selected root domain is no longer locally mineable. Skipping this tip and waiting for the next block.";
+}
+function createRetryableMiningPublishWaitingNote() {
+    return "Selected mining candidate did not reach mempool and will be retried on the current tip with refreshed wallet state.";
 }
 async function generateCandidatesForDomains(options) {
     const bestBlockHash = options.readContext.nodeStatus?.nodeBestHashHex;
@@ -791,7 +953,7 @@ async function generateCandidatesForDomains(options) {
             referencedBlockHashDisplay: bestBlockHash,
             generatedAtUnixMs: Date.now(),
             extraPrompt: null,
-            limits: createGenerateSentencesHookLimits(),
+            limits: createMiningSentenceRequestLimits(),
             rootDomains: rootDomains.map((domain) => ({
                 domainId: domain.domainId,
                 domainName: domain.domainName,
@@ -803,7 +965,6 @@ async function generateCandidatesForDomains(options) {
             generated = await generateMiningSentences(generationRequest, {
                 paths: options.paths,
                 provider: options.provider,
-                hookState: options.readContext.localState.state.hookClientState.mining,
                 signal: abortController.signal,
                 fetchImpl: options.fetchImpl,
             });
@@ -833,15 +994,6 @@ async function generateCandidatesForDomains(options) {
             dataDir: options.readContext.dataDir,
             truthKey: options.indexerTruthKey,
         });
-        if (generated.hookMode === "custom") {
-            await persistCustomHookRuntimeOutcome({
-                readContext: options.readContext,
-                provider: options.provider,
-                paths: options.paths,
-                nowUnixMs: Date.now(),
-                success: true,
-            });
-        }
         const sentencesByDomain = new Map();
         for (const candidate of generated.candidates) {
             const existing = sentencesByDomain.get(candidate.domainId) ?? [];
@@ -864,7 +1016,6 @@ async function generateCandidatesForDomains(options) {
                 domainName: domain.domainName,
                 localIndex: domain.localIndex,
                 sender: domain.sender,
-                anchorOutpoint: domain.anchorOutpoint,
                 sentence: best.sentence,
                 encodedSentenceBytes: best.encodedSentenceBytes,
                 bip39WordIndices: [...best.bip39WordIndices],
@@ -914,6 +1065,46 @@ async function chooseBestLocalCandidate(candidates) {
     }
     return candidates.find((candidate) => candidate.domainId === winner.miningDomainId) ?? null;
 }
+function isBetterVisibleCompetitor(candidate, current) {
+    if (current === undefined) {
+        return true;
+    }
+    if (candidate.canonicalBlend !== current.canonicalBlend) {
+        return candidate.canonicalBlend > current.canonicalBlend;
+    }
+    if (candidate.effectiveFeeRate !== current.effectiveFeeRate) {
+        return candidate.effectiveFeeRate > current.effectiveFeeRate;
+    }
+    return candidate.txid.localeCompare(current.txid) < 0;
+}
+function rankMiningSentenceEntries(entries, blendSeed) {
+    return entries
+        .map((entry) => ({
+        ...entry,
+        tieBreak: tieBreakHash(blendSeed, entry.domainId),
+    }))
+        .sort((left, right) => {
+        if (left.canonicalBlend !== right.canonicalBlend) {
+            return left.canonicalBlend > right.canonicalBlend ? -1 : 1;
+        }
+        const tieBreakOrder = compareLexicographically(left.tieBreak, right.tieBreak);
+        if (tieBreakOrder !== 0) {
+            return tieBreakOrder;
+        }
+        return left.txIndex - right.txIndex;
+    })
+        .map((entry, index) => ({
+        ...entry,
+        rank: index + 1,
+    }));
+}
+function toSentenceBoardEntries(entries) {
+    return entries.slice(0, 5).map((entry) => ({
+        rank: entry.rank,
+        domainName: entry.domainName,
+        sentence: entry.sentence,
+    }));
+}
 async function runCompetitivenessGate(options) {
     const createDecision = (overrides) => ({
         allowed: overrides.allowed ?? false,
@@ -924,10 +1115,11 @@ async function runCompetitivenessGate(options) {
         competitivenessGateIndeterminate: overrides.competitivenessGateIndeterminate ?? false,
         mempoolSequenceCacheStatus: overrides.mempoolSequenceCacheStatus ?? null,
         lastMempoolSequence: overrides.lastMempoolSequence ?? null,
+        visibleBoardEntries: overrides.visibleBoardEntries ?? [],
+        candidateRank: overrides.candidateRank ?? null,
     });
     const walletRootId = options.readContext.localState.walletRootId ?? "uninitialized-wallet-root";
     const indexerTruthKey = getIndexerTruthKey(options.readContext);
-    const localFeeTarget = DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB;
     const excludedTxids = [options.currentTxid].filter((value) => value !== null).sort();
     const localAssayTupleKey = [
         options.candidate.domainId,
@@ -959,7 +1151,6 @@ async function runCompetitivenessGate(options) {
         && cachedTruthMatches
         && cachedReferencedBlockMatches
         && cached.localAssayTupleKey === localAssayTupleKey
-        && cached.currentFeeTargetSatVb === localFeeTarget
         && cached.excludedTxidsKey === excludedTxids.join(",")
         && cached.mempoolSequence === mempoolSequence) {
         return {
@@ -1005,7 +1196,7 @@ async function runCompetitivenessGate(options) {
     const entries = new Map();
     for (const txid of visibleTxids) {
         const context = txContexts.get(txid);
-        if (context === undefined || context.effectiveFeeRate < localFeeTarget || context.payload === null || context.senderScriptHex === null) {
+        if (context === undefined || context.payload === null || context.senderScriptHex === null) {
             continue;
         }
         const decoded = decodeMinePayload(context.payload);
@@ -1031,7 +1222,6 @@ async function runCompetitivenessGate(options) {
                 indexerSnapshotSeq: indexerTruthKey?.snapshotSeq ?? "none",
                 referencedBlockHashDisplay: options.candidate.referencedBlockHashDisplay,
                 localAssayTupleKey,
-                currentFeeTargetSatVb: localFeeTarget,
                 excludedTxidsKey: excludedTxids.join(","),
                 mempoolSequence,
                 txids: [...visibleTxids],
@@ -1052,26 +1242,46 @@ async function runCompetitivenessGate(options) {
             txid,
             effectiveFeeRate: context.effectiveFeeRate,
             domainId: decoded.domainId,
+            domainName: overlayDomain.name,
+            sentence: Buffer.from(decoded.sentenceBytes).toString("utf8"),
             senderScriptHex: context.senderScriptHex,
             encodedSentenceBytesHex: Buffer.from(scored.encodedSentenceBytes).toString("hex"),
             bip39WordIndices: [...scored.bip39WordIndices],
             canonicalBlend: scored.canonicalBlend,
         });
     }
-    const sameDomainCompetitors = [...entries.values()].filter((entry) => entry.domainId === options.candidate.domainId);
+    const blendSeed = deriveBlendSeed(options.candidate.referencedBlockHashInternal);
+    const visibleBestByDomain = new Map();
+    for (const entry of entries.values()) {
+        const current = visibleBestByDomain.get(entry.domainId);
+        if (isBetterVisibleCompetitor(entry, current)) {
+            visibleBestByDomain.set(entry.domainId, entry);
+        }
+    }
+    const visibleRankedEntries = rankMiningSentenceEntries([...visibleBestByDomain.values()]
+        .sort((left, right) => left.domainId - right.domainId || left.txid.localeCompare(right.txid))
+        .map((entry, index) => ({
+        domainId: entry.domainId,
+        domainName: entry.domainName,
+        sentence: entry.sentence,
+        canonicalBlend: entry.canonicalBlend,
+        senderScriptHex: entry.senderScriptHex,
+        encodedSentenceBytesHex: entry.encodedSentenceBytesHex,
+        bip39WordIndices: entry.bip39WordIndices,
+        txid: entry.txid,
+        txIndex: index,
+    })), blendSeed);
+    const sameDomainCompetitors = [...visibleBestByDomain.values()].filter((entry) => entry.domainId === options.candidate.domainId);
     const sameDomainCompetitorSuppressed = sameDomainCompetitors.some((competitor) => competitor.canonicalBlend > options.candidate.canonicalBlend
         || competitor.canonicalBlend === options.candidate.canonicalBlend);
     let decision;
     const otherDomainBest = new Map();
-    for (const entry of entries.values()) {
+    for (const entry of visibleBestByDomain.values()) {
         if (entry.domainId === options.candidate.domainId) {
             continue;
         }
         const best = otherDomainBest.get(entry.domainId);
-        if (best === undefined
-            || entry.canonicalBlend > best.canonicalBlend
-            || (entry.canonicalBlend === best.canonicalBlend && entry.effectiveFeeRate > best.effectiveFeeRate)
-            || (entry.canonicalBlend === best.canonicalBlend && entry.effectiveFeeRate === best.effectiveFeeRate && entry.txid.localeCompare(best.txid) < 0)) {
+        if (isBetterVisibleCompetitor(entry, best)) {
             otherDomainBest.set(entry.domainId, entry);
         }
     }
@@ -1085,38 +1295,41 @@ async function runCompetitivenessGate(options) {
             competitivenessGateIndeterminate: false,
             mempoolSequenceCacheStatus: "refreshed",
             lastMempoolSequence: mempoolSequence,
+            visibleBoardEntries: toSentenceBoardEntries(visibleRankedEntries),
         });
     }
     else {
         try {
-            const submissions = [
+            const candidateRankedEntries = rankMiningSentenceEntries([
                 {
-                    miningDomainId: options.candidate.domainId,
-                    rawSentenceBytes: options.candidate.encodedSentenceBytes,
-                    recipientScriptPubKey: Buffer.from(options.candidate.sender.scriptPubKeyHex, "hex"),
+                    domainId: options.candidate.domainId,
+                    domainName: options.candidate.domainName,
+                    sentence: options.candidate.sentence,
+                    canonicalBlend: options.candidate.canonicalBlend,
+                    senderScriptHex: options.candidate.sender.scriptPubKeyHex,
+                    encodedSentenceBytesHex: Buffer.from(options.candidate.encodedSentenceBytes).toString("hex"),
                     bip39WordIndices: options.candidate.bip39WordIndices,
+                    txid: null,
                     txIndex: 0,
                 },
                 ...[...otherDomainBest.values()]
                     .sort((left, right) => left.domainId - right.domainId || left.txid.localeCompare(right.txid))
                     .map((entry, index) => ({
-                    miningDomainId: entry.domainId,
-                    rawSentenceBytes: Buffer.from(entry.encodedSentenceBytesHex, "hex"),
-                    recipientScriptPubKey: Buffer.from(entry.senderScriptHex, "hex"),
+                    domainId: entry.domainId,
+                    domainName: entry.domainName,
+                    sentence: entry.sentence,
+                    canonicalBlend: entry.canonicalBlend,
+                    senderScriptHex: entry.senderScriptHex,
+                    encodedSentenceBytesHex: entry.encodedSentenceBytesHex,
                     bip39WordIndices: entry.bip39WordIndices,
+                    txid: entry.txid,
                     txIndex: index + 1,
                 })),
-            ];
-            const winners = await settleBlock({
-                blendSeed: deriveBlendSeed(options.candidate.referencedBlockHashInternal),
-                blockRewardCogtoshi: 100n,
-                submissions,
-            });
-            const localWinner = winners.find((winner) => winner.miningDomainId === options.candidate.domainId);
-            const higherRankedCompetitorDomainCount = localWinner === undefined
-                ? Math.max(0, winners.length - 1)
-                : Math.max(0, localWinner.rank - 1);
-            if (higherRankedCompetitorDomainCount >= 5) {
+            ], blendSeed);
+            const localEntry = candidateRankedEntries.find((entry) => entry.txid === null) ?? null;
+            const candidateRank = localEntry?.rank ?? null;
+            const higherRankedCompetitorDomainCount = candidateRank === null ? 0 : Math.max(0, candidateRank - 1);
+            if (candidateRank !== null && candidateRank > 5) {
                 decision = createDecision({
                     allowed: false,
                     decision: "suppressed-top5-mempool",
@@ -1126,11 +1339,13 @@ async function runCompetitivenessGate(options) {
                     competitivenessGateIndeterminate: false,
                     mempoolSequenceCacheStatus: "refreshed",
                     lastMempoolSequence: mempoolSequence,
+                    visibleBoardEntries: toSentenceBoardEntries(visibleRankedEntries),
+                    candidateRank,
                 });
             }
             else {
                 decision = createDecision({
-                    allowed: true,
+                    allowed: candidateRank !== null,
                     decision: "publish",
                     sameDomainCompetitorSuppressed: false,
                     higherRankedCompetitorDomainCount,
@@ -1138,6 +1353,8 @@ async function runCompetitivenessGate(options) {
                     competitivenessGateIndeterminate: false,
                     mempoolSequenceCacheStatus: "refreshed",
                     lastMempoolSequence: mempoolSequence,
+                    visibleBoardEntries: toSentenceBoardEntries(visibleRankedEntries),
+                    candidateRank,
                 });
             }
         }
@@ -1151,6 +1368,7 @@ async function runCompetitivenessGate(options) {
                 competitivenessGateIndeterminate: true,
                 mempoolSequenceCacheStatus: "refreshed",
                 lastMempoolSequence: mempoolSequence,
+                visibleBoardEntries: toSentenceBoardEntries(visibleRankedEntries),
             });
         }
     }
@@ -1159,7 +1377,6 @@ async function runCompetitivenessGate(options) {
         indexerSnapshotSeq: indexerTruthKey?.snapshotSeq ?? "none",
         referencedBlockHashDisplay: options.candidate.referencedBlockHashDisplay,
         localAssayTupleKey,
-        currentFeeTargetSatVb: localFeeTarget,
         excludedTxidsKey: excludedTxids.join(","),
         mempoolSequence,
         txids: [...visibleTxids],
@@ -1168,74 +1385,14 @@ async function runCompetitivenessGate(options) {
     });
     return decision;
 }
-function candidateOutranksLive(options) {
-    const liveState = normalizeMiningStateRecord(options.liveState);
-    const nextSentenceHex = Buffer.from(options.candidate.encodedSentenceBytes).toString("hex");
-    if (liveState.currentEncodedSentenceBytesHex === null) {
-        return true;
-    }
-    if (liveState.currentDomainId === options.candidate.domainId) {
-        if (liveState.currentEncodedSentenceBytesHex === nextSentenceHex) {
-            return false;
-        }
-        const currentScore = liveState.currentScore === null ? null : BigInt(liveState.currentScore);
-        return currentScore === null || options.candidate.canonicalBlend > currentScore;
-    }
-    return true;
-}
-function candidateMatchesLiveFamily(options) {
+function livePublishTargetsCandidateTip(options) {
     const liveState = normalizeMiningStateRecord(options.liveState);
-    return liveState.currentDomainId === options.candidate.domainId
-        && liveState.currentEncodedSentenceBytesHex === Buffer.from(options.candidate.encodedSentenceBytes).toString("hex")
-        && liveState.currentSenderScriptPubKeyHex === options.candidate.sender.scriptPubKeyHex
+    return liveState.currentTxid !== null
+        && liveState.currentPublishState === "in-mempool"
+        && liveState.livePublishInMempool === true
         && liveState.currentReferencedBlockHashDisplay === options.candidate.referencedBlockHashDisplay
         && liveState.currentBlockTargetHeight === options.candidate.targetBlockHeight;
 }
-function candidateNeedsFeeMaintenance(options) {
-    const liveState = normalizeMiningStateRecord(options.liveState);
-    return candidateMatchesLiveFamily(options)
-        && liveState.currentTxid !== null
-        && liveState.currentFeeRateSatVb !== null
-        && liveState.currentPublishState === "in-mempool"
-        && liveState.liveMiningFamilyInMempool === true;
-}
-async function candidateWinsAgainstLive(options) {
-    const liveState = normalizeMiningStateRecord(options.liveState);
-    if (liveState.currentDomainId === null || liveState.currentEncodedSentenceBytesHex === null) {
-        return true;
-    }
-    if (liveState.currentDomainId === options.candidate.domainId) {
-        return candidateOutranksLive(options);
-    }
-    if (liveState.currentBip39WordIndices === null || liveState.currentSenderScriptPubKeyHex === null || liveState.currentBlendSeedHex === null) {
-        return true;
-    }
-    const settled = await settleBlock({
-        blendSeed: Buffer.from(liveState.currentBlendSeedHex, "hex"),
-        blockRewardCogtoshi: 100n,
-        submissions: [
-            {
-                miningDomainId: liveState.currentDomainId,
-                rawSentenceBytes: Buffer.from(liveState.currentEncodedSentenceBytesHex, "hex"),
-                recipientScriptPubKey: Buffer.from(liveState.currentSenderScriptPubKeyHex, "hex"),
-                bip39WordIndices: liveState.currentBip39WordIndices,
-                txIndex: 0,
-            },
-            {
-                miningDomainId: options.candidate.domainId,
-                rawSentenceBytes: options.candidate.encodedSentenceBytes,
-                recipientScriptPubKey: Buffer.from(options.candidate.sender.scriptPubKeyHex, "hex"),
-                bip39WordIndices: options.candidate.bip39WordIndices,
-                txIndex: 1,
-            },
-        ],
-    });
-    const incumbent = settled.find((entry) => entry.miningDomainId === liveState.currentDomainId);
-    const challenger = settled.find((entry) => entry.miningDomainId === options.candidate.domainId);
-    return challenger !== undefined
-        && incumbent !== undefined
-        && challenger.rank < incumbent.rank;
-}
 function miningCandidateIsCurrent(options) {
     return options.state.currentReferencedBlockHashDisplay !== null
         && options.nodeBestHash !== null
@@ -1250,14 +1407,17 @@ async function reconcileLiveMiningState(options) {
         miningState: normalizeMiningStateRecord(options.state.miningState),
     };
     const currentTxid = state.miningState.currentTxid;
-    if (currentTxid === null || !miningFamilyMayStillExist(state.miningState)) {
+    if (currentTxid === null || !miningPublishMayStillExist(state.miningState)) {
         await reconcilePersistentPolicyLocks({
             rpc: options.rpc,
             walletName: state.managedCoreWallet.walletName,
             state,
             fixedInputs: [],
         });
-        return state;
+        return {
+            state,
+            recentWin: null,
+        };
     }
     const walletName = state.managedCoreWallet.walletName;
     const [mempoolVerbose, walletTx] = await Promise.all([
@@ -1269,10 +1429,11 @@ async function reconcileLiveMiningState(options) {
     ]);
     const inMempool = mempoolVerbose.txids.includes(currentTxid);
     if (walletTx !== null && walletTx.confirmations > 0) {
+        const recentWin = findRecentMiningWin(options.snapshotState ?? null, currentTxid, state.miningState.currentBlockTargetHeight);
         state = {
             ...state,
             miningState: {
-                ...clearMiningFamilyState(state.miningState),
+                ...clearMiningPublishState(state.miningState),
                 currentPublishDecision: "tx-confirmed-while-down",
             },
         };
@@ -1282,7 +1443,10 @@ async function reconcileLiveMiningState(options) {
             state,
             fixedInputs: [],
         });
-        return state;
+        return {
+            state,
+            recentWin,
+        };
     }
     if (inMempool) {
         const stale = !miningCandidateIsCurrent({
@@ -1291,7 +1455,7 @@ async function reconcileLiveMiningState(options) {
             nodeBestHeight: options.nodeBestHeight,
         });
         state = defaultMiningStatePatch(state, {
-            liveMiningFamilyInMempool: true,
+            livePublishInMempool: true,
             currentPublishState: "in-mempool",
             state: stale
                 ? "paused-stale"
@@ -1303,7 +1467,7 @@ async function reconcileLiveMiningState(options) {
                 : state.miningState.runMode === "stopped"
                     ? "user-stopped"
                     : null,
-            currentPublishDecision: stale ? "paused-stale-mempool" : "restored-live-family",
+            currentPublishDecision: stale ? "paused-stale-mempool" : "restored-live-publish",
         });
         await reconcilePersistentPolicyLocks({
             rpc: options.rpc,
@@ -1311,7 +1475,10 @@ async function reconcileLiveMiningState(options) {
             state,
             fixedInputs: [],
         });
-        return state;
+        return {
+            state,
+            recentWin: null,
+        };
     }
     if ((walletTx?.walletconflicts?.length ?? 0) > 0) {
         state = defaultMiningStatePatch(state, {
@@ -1319,7 +1486,7 @@ async function reconcileLiveMiningState(options) {
             pauseReason: state.miningState.currentPublishState === "broadcast-unknown"
                 ? "broadcast-unknown-conflict"
                 : "wallet-conflict-observed",
-            liveMiningFamilyInMempool: false,
+            livePublishInMempool: false,
             currentPublishDecision: state.miningState.currentPublishState === "broadcast-unknown"
                 ? "repair-required-broadcast-conflict"
                 : "repair-required-wallet-conflict",
@@ -1330,13 +1497,16 @@ async function reconcileLiveMiningState(options) {
             state,
             fixedInputs: [],
         });
-        return state;
+        return {
+            state,
+            recentWin: null,
+        };
     }
     state = defaultMiningStatePatch(state, {
-        ...clearMiningFamilyState(state.miningState),
+        ...clearMiningPublishState(state.miningState),
         currentPublishDecision: state.miningState.currentPublishState === "broadcast-unknown"
             ? "broadcast-unknown-not-seen"
-            : "live-family-not-seen",
+            : "live-publish-not-seen",
     });
     await reconcilePersistentPolicyLocks({
         rpc: options.rpc,
@@ -1344,9 +1514,12 @@ async function reconcileLiveMiningState(options) {
         state,
         fixedInputs: [],
     });
-    return state;
+    return {
+        state,
+        recentWin: null,
+    };
 }
-async function publishCandidate(options) {
+async function publishCandidateOnce(options) {
     const service = await options.attachService({
         dataDir: options.dataDir,
         chain: "main",
@@ -1354,48 +1527,35 @@ async function publishCandidate(options) {
         walletRootId: options.readContext.localState.state.walletRootId,
     });
     const rpc = options.rpcFactory(service.rpc);
-    let state = await reconcileLiveMiningState({
+    let state = (await reconcileLiveMiningState({
         state: options.readContext.localState.state,
         rpc,
         nodeBestHash: options.readContext.nodeStatus?.nodeBestHashHex ?? null,
         nodeBestHeight: options.readContext.nodeStatus?.nodeBestHeight ?? null,
-    });
+        snapshotState: options.readContext.snapshot.state,
+    })).state;
     const allUtxos = await rpc.listUnspent(state.managedCoreWallet.walletName, 0);
-    const fundingConflict = state.miningState.sharedMiningConflictOutpoint
-        ?? allUtxos.find((entry) => entry.scriptPubKey === state.funding.scriptPubKeyHex
-            && entry.confirmations >= 1
-            && entry.spendable !== false
-            && entry.safe !== false
-            && !(entry.txid === options.candidate.anchorOutpoint.txid && entry.vout === options.candidate.anchorOutpoint.vout));
-    if (fundingConflict === undefined || fundingConflict === null) {
-        throw new Error("wallet_mining_missing_conflict_utxo");
-    }
-    const conflictOutpoint = "txid" in fundingConflict
-        ? { txid: fundingConflict.txid, vout: fundingConflict.vout }
-        : fundingConflict;
+    const conflictOutpoint = resolveMiningConflictOutpoint({
+        state,
+        allUtxos,
+    });
     const priorMiningState = cloneMiningState(state.miningState);
-    const nextFeeRate = state.miningState.currentFeeRateSatVb === null
-        ? DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB
-        : state.miningState.currentFeeRateSatVb + 1;
-    const shouldFeeBump = candidateNeedsFeeMaintenance({
+    if (livePublishTargetsCandidateTip({
         liveState: state.miningState,
         candidate: options.candidate,
-    });
-    if (state.miningState.currentPublishState === "in-mempool"
-        && state.miningState.liveMiningFamilyInMempool === true
-        && !shouldFeeBump
-        && !await candidateWinsAgainstLive({
-            liveState: state.miningState,
-            candidate: options.candidate,
-        })) {
+    })) {
         return {
             state: defaultMiningStatePatch(state, {
-                currentPublishDecision: "kept-live-family",
+                currentPublishDecision: "kept-live-publish",
             }),
             txid: state.miningState.currentTxid,
-            decision: "kept-live-family",
+            decision: "kept-live-publish",
         };
     }
+    const feeSelection = await resolveWalletMutationFeeSelection({
+        rpc,
+    });
+    const nextFeeRate = feeSelection.feeRateSatVb;
     const plan = createMiningPlan({
         state,
         candidate: options.candidate,
@@ -1430,18 +1590,14 @@ async function publishCandidate(options) {
         currentReferencedBlockHashDisplay: options.candidate.referencedBlockHashDisplay,
         currentIntentFingerprintHex: intentFingerprintHex,
         sharedMiningConflictOutpoint: conflictOutpoint,
-        liveMiningFamilyInMempool: null,
+        livePublishInMempool: null,
         currentPublishDecision: priorMiningState.currentTxid === null
             ? "publishing"
-            : shouldFeeBump
-                ? "fee-bump"
-                : "replacing",
+            : "replacing",
     });
     await saveWalletStatePreservingUnlock({
         state,
         provider: options.provider,
-        unlockUntilUnixMs: options.readContext.localState.unlockUntilUnixMs,
-        nowUnixMs: Date.now(),
         paths: options.paths,
     });
     try {
@@ -1451,13 +1607,11 @@ async function publishCandidate(options) {
         if (isAlreadyAcceptedError(error)) {
             state = defaultMiningStatePatch(state, {
                 currentPublishState: "in-mempool",
-                liveMiningFamilyInMempool: true,
+                livePublishInMempool: true,
             });
             await saveWalletStatePreservingUnlock({
                 state,
                 provider: options.provider,
-                unlockUntilUnixMs: options.readContext.localState.unlockUntilUnixMs,
-                nowUnixMs: Date.now(),
                 paths: options.paths,
             });
             await appendEvent(options.paths, createEvent(state.miningState.currentPublishDecision === "replacing" ? "tx-replaced" : "tx-broadcast", `Mining transaction ${built.txid} is already accepted by the local node.`, {
@@ -1474,11 +1628,9 @@ async function publishCandidate(options) {
             return {
                 state,
                 txid: built.txid,
-                decision: state.miningState.currentPublishDecision === "fee-bump"
-                    ? "fee-bump"
-                    : state.miningState.currentPublishDecision === "replacing"
-                        ? "replaced"
-                        : "broadcast",
+                decision: state.miningState.currentPublishDecision === "replacing"
+                    ? "replaced"
+                    : "broadcast",
             };
         }
         if (isBroadcastUnknownError(error)) {
@@ -1489,8 +1641,6 @@ async function publishCandidate(options) {
             await saveWalletStatePreservingUnlock({
                 state,
                 provider: options.provider,
-                unlockUntilUnixMs: options.readContext.localState.unlockUntilUnixMs,
-                nowUnixMs: Date.now(),
                 paths: options.paths,
             });
             await appendEvent(options.paths, createEvent("error", `Mining broadcast became uncertain for ${built.txid}.`, {
@@ -1512,7 +1662,16 @@ async function publishCandidate(options) {
                 decision: "broadcast-unknown",
             };
         }
-        throw error;
+        state = {
+            ...state,
+            miningState: cloneMiningState(priorMiningState),
+        };
+        await saveWalletStatePreservingUnlock({
+            state,
+            provider: options.provider,
+            paths: options.paths,
+        });
+        throw new MiningPublishRejectedError(error instanceof Error ? error.message : String(error), state);
     }
     const absoluteFeeSats = numberToSats(built.funded.fee);
     const replacementCount = priorMiningState.currentTxid === null
@@ -1520,12 +1679,10 @@ async function publishCandidate(options) {
         : priorMiningState.replacementCount + 1;
     state = defaultMiningStatePatch(state, {
         currentPublishState: "in-mempool",
-        liveMiningFamilyInMempool: true,
-        currentPublishDecision: state.miningState.currentPublishDecision === "fee-bump"
-            ? "fee-bump"
-            : state.miningState.currentPublishDecision === "replacing"
-                ? "replaced"
-                : "broadcast",
+        livePublishInMempool: true,
+        currentPublishDecision: state.miningState.currentPublishDecision === "replacing"
+            ? "replaced"
+            : "broadcast",
         replacementCount,
         currentAbsoluteFeeSats: Number(absoluteFeeSats),
         currentBlockFeeSpentSats: (BigInt(state.miningState.currentBlockFeeSpentSats) + absoluteFeeSats).toString(),
@@ -1535,19 +1692,13 @@ async function publishCandidate(options) {
     await saveWalletStatePreservingUnlock({
         state,
         provider: options.provider,
-        unlockUntilUnixMs: options.readContext.localState.unlockUntilUnixMs,
-        nowUnixMs: Date.now(),
         paths: options.paths,
     });
     await appendEvent(options.paths, createEvent(state.miningState.currentPublishDecision === "replaced"
         ? "tx-replaced"
-        : state.miningState.currentPublishDecision === "fee-bump"
-            ? "tx-fee-bump"
-            : "tx-broadcast", `${state.miningState.currentPublishDecision === "replaced"
+        : "tx-broadcast", `${state.miningState.currentPublishDecision === "replaced"
         ? "Replaced"
-        : state.miningState.currentPublishDecision === "fee-bump"
-            ? "Fee-bumped"
-            : "Broadcast"} mining transaction ${built.txid}.`, {
+        : "Broadcast"} mining transaction ${built.txid}.`, {
         runId: options.runId,
         targetBlockHeight: options.candidate.targetBlockHeight,
         referencedBlockHashDisplay: options.candidate.referencedBlockHashDisplay,
@@ -1561,21 +1712,106 @@ async function publishCandidate(options) {
     return {
         state,
         txid: built.txid,
-        decision: state.miningState.currentPublishDecision === "fee-bump"
-            ? "fee-bump"
-            : state.miningState.currentPublishDecision === "replaced"
-                ? "replaced"
-                : "broadcast",
+        decision: state.miningState.currentPublishDecision === "replaced"
+            ? "replaced"
+            : "broadcast",
     };
 }
-async function ensureBuiltInSetupIfNeeded(options) {
-    const unlocked = await loadOrAutoUnlockWalletState({
-        provider: options.provider,
+async function publishCandidate(options) {
+    const publishAttempt = options.publishAttempt ?? publishCandidateOnce;
+    const appendEventFn = options.appendEventFn ?? appendEvent;
+    const createStaleCandidateSkipResult = async (state) => {
+        const note = createStaleMiningCandidateWaitingNote();
+        await appendEventFn(options.paths, createEvent("publish-skipped-stale-candidate", "Skipped mining publish for the current tip because the selected root domain is no longer locally mineable.", {
+            level: "warn",
+            runId: options.runId,
+            targetBlockHeight: options.candidate.targetBlockHeight,
+            referencedBlockHashDisplay: options.candidate.referencedBlockHashDisplay,
+            domainId: options.candidate.domainId,
+            domainName: options.candidate.domainName,
+            score: options.candidate.canonicalBlend.toString(),
+            reason: "candidate-unavailable",
+        }));
+        return {
+            state,
+            txid: null,
+            decision: "publish-skipped-stale-candidate",
+            note,
+            skipped: true,
+            candidate: null,
+        };
+    };
+    const lockedReadContext = await options.openReadContext({
+        dataDir: options.dataDir,
+        databasePath: options.databasePath,
+        secretProvider: options.provider,
+        walletControlLockHeld: true,
         paths: options.paths,
     });
-    if (unlocked?.state.hookClientState.mining.mode === "custom") {
-        return true;
+    try {
+        if (lockedReadContext.localState.availability !== "ready"
+            || lockedReadContext.localState.state === null
+            || lockedReadContext.snapshot === null
+            || lockedReadContext.model === null) {
+            return await createStaleCandidateSkipResult(options.fallbackState);
+        }
+        const readyReadContext = lockedReadContext;
+        const refreshedCandidate = refreshMiningCandidateFromCurrentState(readyReadContext, options.candidate);
+        if (refreshedCandidate === null) {
+            return await createStaleCandidateSkipResult(readyReadContext.localState.state);
+        }
+        try {
+            const published = await publishAttempt({
+                readContext: readyReadContext,
+                candidate: refreshedCandidate,
+                dataDir: options.dataDir,
+                provider: options.provider,
+                paths: options.paths,
+                attachService: options.attachService,
+                rpcFactory: options.rpcFactory,
+                runId: options.runId,
+            });
+            return {
+                ...published,
+                candidate: refreshedCandidate,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === "wallet_mining_mempool_rejected_missing-inputs") {
+                const note = createRetryableMiningPublishWaitingNote();
+                const revertedState = error instanceof MiningPublishRejectedError
+                    ? error.revertedState
+                    : readyReadContext.localState.state;
+                await appendEventFn(options.paths, createEvent("publish-retry-pending", "Selected mining candidate did not reach mempool and will be retried on the current tip with refreshed wallet state.", {
+                    level: "warn",
+                    runId: options.runId,
+                    targetBlockHeight: refreshedCandidate.targetBlockHeight,
+                    referencedBlockHashDisplay: refreshedCandidate.referencedBlockHashDisplay,
+                    domainId: refreshedCandidate.domainId,
+                    domainName: refreshedCandidate.domainName,
+                    score: refreshedCandidate.canonicalBlend.toString(),
+                    reason: "missing-inputs",
+                }));
+                return {
+                    state: revertedState,
+                    txid: null,
+                    decision: "publish-retry-pending",
+                    note,
+                    retryable: true,
+                    candidate: refreshedCandidate,
+                };
+            }
+            throw error;
+        }
     }
+    finally {
+        await lockedReadContext.close();
+    }
+}
+export async function publishCandidateForTesting(options) {
+    return await publishCandidate(options);
+}
+async function ensureBuiltInSetupIfNeeded(options) {
     const config = await loadClientConfig({
         path: options.paths.clientConfigPath,
         provider: options.provider,
@@ -1614,7 +1850,7 @@ async function performMiningCycle(options) {
                 backgroundWorkerHeartbeatAtUnixMs: options.runMode === "background" ? Date.now() : null,
             },
         });
-        if (readContext.localState.availability !== "ready" || readContext.localState.state === null || readContext.localState.unlockUntilUnixMs === null) {
+        if (readContext.localState.availability !== "ready" || readContext.localState.state === null) {
             await refreshAndSaveStatus({
                 paths: options.paths,
                 provider: options.provider,
@@ -1622,9 +1858,10 @@ async function performMiningCycle(options) {
                 overrides: {
                     runMode: options.runMode,
                     currentPhase: "waiting",
-                    note: "Wallet must stay unlocked for mining to continue.",
+                    note: "Wallet state must be locally available for mining to continue.",
                 },
                 visualizer: options.visualizer,
+                visualizerState: options.loopState.ui,
             });
             return;
         }
@@ -1636,20 +1873,20 @@ async function performMiningCycle(options) {
         });
         checkpointMiningSuspendDetector(options.suspendDetector);
         const rpc = options.rpcFactory(service.rpc);
-        const reconciledState = await reconcileLiveMiningState({
+        const reconciliation = await reconcileLiveMiningState({
             state: readContext.localState.state,
             rpc,
             nodeBestHash: readContext.nodeStatus?.nodeBestHashHex ?? null,
             nodeBestHeight: readContext.nodeStatus?.nodeBestHeight ?? null,
+            snapshotState: readContext.snapshot?.state ?? null,
         });
+        const reconciledState = reconciliation.state;
         checkpointMiningSuspendDetector(options.suspendDetector);
         let effectiveReadContext = readContext;
         if (JSON.stringify(reconciledState.miningState) !== JSON.stringify(readContext.localState.state.miningState)) {
             await saveWalletStatePreservingUnlock({
                 state: reconciledState,
                 provider: options.provider,
-                unlockUntilUnixMs: readContext.localState.unlockUntilUnixMs,
-                nowUnixMs: Date.now(),
                 paths: options.paths,
             });
             effectiveReadContext = {
@@ -1657,11 +1894,23 @@ async function performMiningCycle(options) {
                 localState: {
                     ...readContext.localState,
                     availability: "ready",
-                    unlockUntilUnixMs: readContext.localState.unlockUntilUnixMs,
                     state: reconciledState,
                 },
             };
         }
+        if (reconciliation.recentWin !== null) {
+            options.loopState.ui.recentWin = reconciliation.recentWin;
+        }
+        if (effectiveReadContext.localState.state.miningState.currentTxid !== null) {
+            options.loopState.ui.latestTxid = effectiveReadContext.localState.state.miningState.currentTxid;
+        }
+        const indexedTip = effectiveReadContext.snapshot?.tip ?? effectiveReadContext.indexer.snapshotTip ?? null;
+        const visibleBlockTimes = await loadMiningVisibleFollowBlockTimes({
+            rpc,
+            indexedTipHeight: indexedTip?.height ?? null,
+            indexedTipHashHex: indexedTip?.blockHashHex ?? null,
+        }).catch(() => ({}));
+        syncMiningVisualizerBlockTimes(options.loopState, visibleBlockTimes);
         if (effectiveReadContext.localState.state.miningState.state === "repair-required") {
             await refreshAndSaveStatus({
                 paths: options.paths,
@@ -1670,9 +1919,10 @@ async function performMiningCycle(options) {
                 overrides: {
                     runMode: options.runMode,
                     currentPhase: "waiting",
-                    note: "Mining is blocked until the current mining family is repaired or reconciled.",
+                    note: "Mining is blocked until the current mining publish is repaired or reconciled.",
                 },
                 visualizer: options.visualizer,
+                visualizerState: options.loopState.ui,
             });
             return;
         }
@@ -1684,8 +1934,6 @@ async function performMiningCycle(options) {
             await saveWalletStatePreservingUnlock({
                 state: nextState,
                 provider: options.provider,
-                unlockUntilUnixMs: effectiveReadContext.localState.unlockUntilUnixMs,
-                nowUnixMs: Date.now(),
                 paths: options.paths,
             });
             effectiveReadContext = {
@@ -1693,7 +1941,6 @@ async function performMiningCycle(options) {
                 localState: {
                     ...effectiveReadContext.localState,
                     availability: "ready",
-                    unlockUntilUnixMs: effectiveReadContext.localState.unlockUntilUnixMs,
                     state: nextState,
                 },
             };
@@ -1704,16 +1951,17 @@ async function performMiningCycle(options) {
                 overrides: {
                     runMode: options.runMode,
                     currentPhase: "waiting",
-                    note: "Mining is paused while another wallet mutation family is active.",
+                    note: "Mining is paused while another wallet mutation is active.",
                 },
                 visualizer: options.visualizer,
+                visualizerState: options.loopState.ui,
             });
             return;
         }
         const preemptionRequest = await readMiningPreemptionRequest(options.paths);
         if (preemptionRequest !== null) {
             const nextState = defaultMiningStatePatch(effectiveReadContext.localState.state, {
-                state: effectiveReadContext.localState.state.miningState.liveMiningFamilyInMempool
+                state: effectiveReadContext.localState.state.miningState.livePublishInMempool
                     && effectiveReadContext.localState.state.miningState.state === "paused-stale"
                     ? "paused-stale"
                     : "paused",
@@ -1722,8 +1970,6 @@ async function performMiningCycle(options) {
             await saveWalletStatePreservingUnlock({
                 state: nextState,
                 provider: options.provider,
-                unlockUntilUnixMs: effectiveReadContext.localState.unlockUntilUnixMs,
-                nowUnixMs: Date.now(),
                 paths: options.paths,
             });
             await refreshAndSaveStatus({
@@ -1742,6 +1988,7 @@ async function performMiningCycle(options) {
                     note: "Mining is paused while another wallet command is preempting sentence generation.",
                 },
                 visualizer: options.visualizer,
+                visualizerState: options.loopState.ui,
             });
             return;
         }
@@ -1768,6 +2015,7 @@ async function performMiningCycle(options) {
                     note: "Mining is waiting for the local Bitcoin node to become publishable.",
                 },
                 visualizer: options.visualizer,
+                visualizerState: options.loopState.ui,
             });
             return;
         }
@@ -1786,10 +2034,22 @@ async function performMiningCycle(options) {
                         : "Mining is waiting for the local Bitcoin node to become publishable.",
                 },
                 visualizer: options.visualizer,
+                visualizerState: options.loopState.ui,
             });
             return;
         }
         const targetBlockHeight = (effectiveReadContext.nodeStatus?.nodeBestHeight ?? 0) + 1;
+        const tipKey = buildMiningTipKey(effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null, targetBlockHeight);
+        if (tipKey !== options.loopState.currentTipKey) {
+            options.loopState.currentTipKey = tipKey;
+            resetMiningUiForTip(options.loopState, targetBlockHeight);
+            if (reconciliation.recentWin !== null) {
+                options.loopState.ui.recentWin = reconciliation.recentWin;
+            }
+        }
+        syncMiningUiSettledBoard(options.loopState, effectiveReadContext.snapshot?.state ?? null, effectiveReadContext.snapshot?.tip?.height ?? effectiveReadContext.indexer.snapshotTip?.height ?? null, effectiveReadContext.nodeStatus?.nodeBestHeight ?? null);
+        const displaySats = await resolveFundingDisplaySats(effectiveReadContext.localState.state, rpc).catch(() => null);
+        syncMiningVisualizerBalances(options.loopState, effectiveReadContext, displaySats);
         if (getBlockRewardCogtoshi(targetBlockHeight) === 0n) {
             const nextState = defaultMiningStatePatch(effectiveReadContext.localState.state, {
                 state: "paused",
@@ -1798,8 +2058,6 @@ async function performMiningCycle(options) {
             await saveWalletStatePreservingUnlock({
                 state: nextState,
                 provider: options.provider,
-                unlockUntilUnixMs: effectiveReadContext.localState.unlockUntilUnixMs,
-                nowUnixMs: Date.now(),
                 paths: options.paths,
             });
             await refreshAndSaveStatus({
@@ -1819,6 +2077,7 @@ async function performMiningCycle(options) {
                     note: "Mining is disabled because the target block reward is zero.",
                 },
                 visualizer: options.visualizer,
+                visualizerState: options.loopState.ui,
             });
             await appendEvent(options.paths, createEvent("publish-skipped-zero-reward", "Skipped mining because the target block reward is zero.", {
                 targetBlockHeight,
@@ -1827,18 +2086,18 @@ async function performMiningCycle(options) {
             }));
             return;
         }
-        const domains = resolveEligibleAnchoredRoots(effectiveReadContext);
-        if (domains.length === 0) {
+        if (tipKey !== null && options.loopState.attemptedTipKey === tipKey) {
             await refreshAndSaveStatus({
                 paths: options.paths,
                 provider: options.provider,
                 readContext: effectiveReadContext,
                 overrides: {
                     runMode: options.runMode,
-                    currentPhase: "idle",
-                    note: "No locally controlled anchored root domains are currently eligible to mine.",
+                    currentPhase: "waiting",
+                    note: options.loopState.waitingNote ?? "Waiting for the next block after the last mining attempt on this tip.",
                 },
                 visualizer: options.visualizer,
+                visualizerState: options.loopState.ui,
             });
             return;
         }
@@ -1866,215 +2125,264 @@ async function performMiningCycle(options) {
                 return false;
             }
         };
-        await refreshAndSaveStatus({
-            paths: options.paths,
-            provider: options.provider,
-            readContext: effectiveReadContext,
-            overrides: {
-                runMode: options.runMode,
-                currentPhase: "generating",
-                note: "Generating mining sentences for eligible root domains.",
-            },
-            visualizer: options.visualizer,
-        });
-        await appendEvent(options.paths, createEvent("hook-request-start", "Started mining sentence generation.", {
-            targetBlockHeight,
-            referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
-            runId: options.backgroundWorkerRunId,
-        }));
-        let candidates;
-        try {
-            candidates = await generateCandidatesForDomains({
-                rpc,
-                readContext: effectiveReadContext,
-                domains,
-                provider: options.provider,
-                paths: options.paths,
-                indexerTruthKey,
-                runId: options.backgroundWorkerRunId,
-                fetchImpl: options.fetchImpl,
-            });
-            checkpointMiningSuspendDetector(options.suspendDetector);
-        }
-        catch (error) {
-            if (error instanceof MiningProviderRequestError) {
+        let selectedCandidate = getSelectedCandidateForTip(options.loopState, tipKey);
+        let gateSnapshot = {
+            higherRankedCompetitorDomainCount: 0,
+            dedupedCompetitorDomainCount: 0,
+            mempoolSequenceCacheStatus: null,
+            lastMempoolSequence: null,
+        };
+        if (selectedCandidate === null) {
+            const domains = resolveEligibleAnchoredRoots(effectiveReadContext);
+            if (domains.length === 0) {
                 await refreshAndSaveStatus({
                     paths: options.paths,
                     provider: options.provider,
                     readContext: effectiveReadContext,
                     overrides: {
                         runMode: options.runMode,
-                        currentPhase: "waiting-provider",
-                        providerState: error.providerState,
-                        lastError: error.message,
-                        note: "Mining is waiting for the sentence provider to recover.",
+                        currentPhase: "idle",
+                        note: "No locally controlled anchored root domains are currently eligible to mine.",
                     },
                     visualizer: options.visualizer,
+                    visualizerState: options.loopState.ui,
                 });
-                await appendEvent(options.paths, createEvent("publish-paused-provider", error.message, {
-                    level: "warn",
-                    targetBlockHeight,
-                    referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
-                    runId: options.backgroundWorkerRunId,
-                }));
                 return;
             }
-            if (error instanceof Error && error.message === "mining_generation_stale_tip") {
-                await appendEvent(options.paths, createEvent("generation-restarted-new-tip", "Detected a new best tip during sentence generation; restarting on the next tick.", {
-                    level: "warn",
-                    targetBlockHeight,
-                    referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
-                    runId: options.backgroundWorkerRunId,
-                }));
-                return;
-            }
-            if (error instanceof Error && error.message === "mining_generation_stale_indexer_truth") {
-                clearMiningGateCache(walletRootId);
-                await appendEvent(options.paths, createEvent("generation-restarted-indexer-truth", "Detected updated coherent indexer truth during sentence generation; restarting on the next tick.", {
-                    level: "warn",
-                    targetBlockHeight,
-                    referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
-                    runId: options.backgroundWorkerRunId,
-                }));
-                return;
-            }
-            if (error instanceof Error && error.message === "mining_generation_preempted") {
-                await appendEvent(options.paths, createEvent("generation-paused-preempted", "Stopped sentence generation because another wallet command requested mining preemption.", {
-                    level: "warn",
-                    targetBlockHeight,
-                    referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
-                    runId: options.backgroundWorkerRunId,
-                }));
-                return;
-            }
-            const hookCooldownActive = await persistCustomHookRuntimeOutcome({
-                readContext: effectiveReadContext,
-                provider: options.provider,
-                paths: options.paths,
-                nowUnixMs: Date.now(),
-                success: false,
-            });
-            const failureMessage = error instanceof Error ? error.message : String(error);
-            await refreshAndSaveStatus({
-                paths: options.paths,
-                provider: options.provider,
-                readContext: effectiveReadContext,
-                overrides: {
-                    runMode: options.runMode,
-                    currentPhase: "waiting-provider",
-                    providerState: effectiveReadContext.localState.state?.hookClientState.mining.mode === "custom"
-                        ? "hook-error"
-                        : undefined,
-                    lastError: failureMessage,
-                    note: effectiveReadContext.localState.state?.hookClientState.mining.mode === "custom"
-                        ? (hookCooldownActive
-                            ? "Custom mining hook launch is paused during the post-failure cooldown window."
-                            : "Custom mining hook failed during sentence generation. Fix it or rerun `cogcoin hooks enable mining`.")
-                        : "Mining sentence generation failed for the current tip.",
-                },
-                visualizer: options.visualizer,
-            });
-            await appendEvent(options.paths, createEvent("hook-request-failed", failureMessage, {
-                level: "error",
-                targetBlockHeight,
-                referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
-                runId: options.backgroundWorkerRunId,
-            }));
-            return;
-        }
-        await refreshAndSaveStatus({
-            paths: options.paths,
-            provider: options.provider,
-            readContext: effectiveReadContext,
-            overrides: {
-                runMode: options.runMode,
-                currentPhase: "scoring",
-                note: "Scoring mining candidates for the current tip.",
-            },
-            visualizer: options.visualizer,
-        });
-        const best = await chooseBestLocalCandidate(candidates);
-        if (best === null) {
             await refreshAndSaveStatus({
                 paths: options.paths,
                 provider: options.provider,
                 readContext: effectiveReadContext,
                 overrides: {
                     runMode: options.runMode,
-                    currentPhase: "idle",
-                    currentPublishDecision: "publish-skipped-no-candidate",
-                    note: "No publishable mining candidate passed scoring gates for the current tip.",
+                    currentPhase: "generating",
+                    note: "Generating mining sentences for eligible root domains.",
                 },
                 visualizer: options.visualizer,
+                visualizerState: options.loopState.ui,
             });
-            await appendEvent(options.paths, createEvent("publish-skipped-no-candidate", "No publishable mining candidate passed scoring gates.", {
+            await appendEvent(options.paths, createEvent("sentence-generation-start", "Started mining sentence generation.", {
                 targetBlockHeight,
                 referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
                 runId: options.backgroundWorkerRunId,
             }));
-            return;
-        }
-        if (!await ensureCurrentIndexerTruthOrRestart()) {
-            return;
-        }
-        writeStdout(options.stdout, `Selected ${best.domainName}: ${best.sentence} (${best.canonicalBlend.toString()})`);
-        await appendEvent(options.paths, createEvent("candidate-selected", `Selected ${best.domainName} with score ${best.canonicalBlend.toString()}.`, {
-            targetBlockHeight: best.targetBlockHeight,
-            referencedBlockHashDisplay: best.referencedBlockHashDisplay,
-            domainId: best.domainId,
-            domainName: best.domainName,
-            score: best.canonicalBlend.toString(),
-            runId: options.backgroundWorkerRunId,
-        }));
-        const gate = await runCompetitivenessGate({
-            rpc,
-            readContext: effectiveReadContext,
-            candidate: best,
-            currentTxid: effectiveReadContext.localState.state.miningState.currentTxid,
-        });
-        checkpointMiningSuspendDetector(options.suspendDetector);
-        if (!gate.allowed) {
+            let candidates;
+            try {
+                candidates = await generateCandidatesForDomains({
+                    rpc,
+                    readContext: effectiveReadContext,
+                    domains,
+                    provider: options.provider,
+                    paths: options.paths,
+                    indexerTruthKey,
+                    runId: options.backgroundWorkerRunId,
+                    fetchImpl: options.fetchImpl,
+                });
+                checkpointMiningSuspendDetector(options.suspendDetector);
+            }
+            catch (error) {
+                if (error instanceof MiningProviderRequestError) {
+                    if (tipKey !== null) {
+                        options.loopState.attemptedTipKey = tipKey;
+                        options.loopState.waitingNote = "Mining is waiting for the sentence provider to recover.";
+                    }
+                    await refreshAndSaveStatus({
+                        paths: options.paths,
+                        provider: options.provider,
+                        readContext: effectiveReadContext,
+                        overrides: {
+                            runMode: options.runMode,
+                            currentPhase: "waiting-provider",
+                            providerState: error.providerState,
+                            lastError: error.message,
+                            note: "Mining is waiting for the sentence provider to recover.",
+                        },
+                        visualizer: options.visualizer,
+                        visualizerState: options.loopState.ui,
+                    });
+                    await appendEvent(options.paths, createEvent("publish-paused-provider", error.message, {
+                        level: "warn",
+                        targetBlockHeight,
+                        referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
+                        runId: options.backgroundWorkerRunId,
+                    }));
+                    return;
+                }
+                if (error instanceof Error && error.message === "mining_generation_stale_tip") {
+                    await appendEvent(options.paths, createEvent("generation-restarted-new-tip", "Detected a new best tip during sentence generation; restarting on the next tick.", {
+                        level: "warn",
+                        targetBlockHeight,
+                        referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
+                        runId: options.backgroundWorkerRunId,
+                    }));
+                    return;
+                }
+                if (error instanceof Error && error.message === "mining_generation_stale_indexer_truth") {
+                    clearMiningGateCache(walletRootId);
+                    await appendEvent(options.paths, createEvent("generation-restarted-indexer-truth", "Detected updated coherent indexer truth during mining; restarting on the next tick.", {
+                        level: "warn",
+                        targetBlockHeight,
+                        referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
+                        runId: options.backgroundWorkerRunId,
+                    }));
+                    return;
+                }
+                if (error instanceof Error && error.message === "mining_generation_preempted") {
+                    await appendEvent(options.paths, createEvent("generation-paused-preempted", "Stopped sentence generation because another wallet command requested mining preemption.", {
+                        level: "warn",
+                        targetBlockHeight,
+                        referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
+                        runId: options.backgroundWorkerRunId,
+                    }));
+                    return;
+                }
+                const failureMessage = error instanceof Error ? error.message : String(error);
+                if (tipKey !== null) {
+                    options.loopState.attemptedTipKey = tipKey;
+                    options.loopState.waitingNote = "Mining sentence generation failed for the current tip.";
+                }
+                await refreshAndSaveStatus({
+                    paths: options.paths,
+                    provider: options.provider,
+                    readContext: effectiveReadContext,
+                    overrides: {
+                        runMode: options.runMode,
+                        currentPhase: "waiting-provider",
+                        providerState: "unavailable",
+                        lastError: failureMessage,
+                        note: "Mining sentence generation failed for the current tip.",
+                    },
+                    visualizer: options.visualizer,
+                    visualizerState: options.loopState.ui,
+                });
+                await appendEvent(options.paths, createEvent("sentence-generation-failed", failureMessage, {
+                    level: "error",
+                    targetBlockHeight,
+                    referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
+                    runId: options.backgroundWorkerRunId,
+                }));
+                return;
+            }
             await refreshAndSaveStatus({
                 paths: options.paths,
                 provider: options.provider,
                 readContext: effectiveReadContext,
                 overrides: {
                     runMode: options.runMode,
-                    currentPhase: "waiting",
-                    currentPublishDecision: gate.decision,
-                    sameDomainCompetitorSuppressed: gate.sameDomainCompetitorSuppressed,
-                    higherRankedCompetitorDomainCount: gate.higherRankedCompetitorDomainCount,
-                    dedupedCompetitorDomainCount: gate.dedupedCompetitorDomainCount,
-                    competitivenessGateIndeterminate: gate.competitivenessGateIndeterminate,
-                    mempoolSequenceCacheStatus: gate.mempoolSequenceCacheStatus,
-                    lastMempoolSequence: gate.lastMempoolSequence,
-                    lastCompetitivenessGateAtUnixMs: Date.now(),
-                    note: gate.decision === "suppressed-same-domain-mempool"
-                        ? "Best local sentence found, but a same-domain mempool competitor already matches or beats it."
-                        : gate.decision === "suppressed-top5-mempool"
-                            ? `Best local sentence found, but ${gate.higherRankedCompetitorDomainCount} stronger competitor root domains are already in mempool.`
-                            : "Mining skipped this tick because the mempool competitiveness gate could not be verified safely.",
+                    currentPhase: "scoring",
+                    note: "Scoring mining candidates for the current tip.",
                 },
                 visualizer: options.visualizer,
+                visualizerState: options.loopState.ui,
             });
-            await appendEvent(options.paths, createEvent(gate.decision === "suppressed-same-domain-mempool"
-                ? "publish-skipped-same-domain-mempool"
-                : gate.decision === "suppressed-top5-mempool"
-                    ? "publish-skipped-top5-mempool"
-                    : "publish-skipped-gate-indeterminate", gate.decision === "suppressed-same-domain-mempool"
-                ? "Skipped publish because a same-domain mempool competitor already outranks the local candidate."
-                : gate.decision === "suppressed-top5-mempool"
-                    ? `Skipped publish because ${gate.higherRankedCompetitorDomainCount} stronger competitor root domains are already in mempool.`
-                    : "Skipped publish because the competitiveness gate could not be evaluated safely.", {
+            const best = await chooseBestLocalCandidate(candidates);
+            if (best === null) {
+                if (tipKey !== null) {
+                    options.loopState.attemptedTipKey = tipKey;
+                    options.loopState.waitingNote = "No publishable mining candidate passed scoring gates for the current tip.";
+                }
+                clearSelectedCandidate(options.loopState);
+                await refreshAndSaveStatus({
+                    paths: options.paths,
+                    provider: options.provider,
+                    readContext: effectiveReadContext,
+                    overrides: {
+                        runMode: options.runMode,
+                        currentPhase: "idle",
+                        currentPublishDecision: "publish-skipped-no-candidate",
+                        note: "No publishable mining candidate passed scoring gates for the current tip.",
+                    },
+                    visualizer: options.visualizer,
+                    visualizerState: options.loopState.ui,
+                });
+                await appendEvent(options.paths, createEvent("publish-skipped-no-candidate", "No publishable mining candidate passed scoring gates.", {
+                    targetBlockHeight,
+                    referencedBlockHashDisplay: effectiveReadContext.nodeStatus?.nodeBestHashHex ?? null,
+                    runId: options.backgroundWorkerRunId,
+                }));
+                return;
+            }
+            if (!await ensureCurrentIndexerTruthOrRestart()) {
+                return;
+            }
+            options.loopState.ui.recentWin = null;
+            cacheSelectedCandidateForTip(options.loopState, tipKey, best);
+            selectedCandidate = best;
+            await appendEvent(options.paths, createEvent("candidate-selected", `Selected ${best.domainName} with score ${best.canonicalBlend.toString()}.`, {
                 targetBlockHeight: best.targetBlockHeight,
                 referencedBlockHashDisplay: best.referencedBlockHashDisplay,
                 domainId: best.domainId,
                 domainName: best.domainName,
                 score: best.canonicalBlend.toString(),
                 runId: options.backgroundWorkerRunId,
-                reason: gate.decision,
             }));
-            return;
+            const gate = await runCompetitivenessGate({
+                rpc,
+                readContext: effectiveReadContext,
+                candidate: best,
+                currentTxid: effectiveReadContext.localState.state.miningState.currentTxid,
+            });
+            checkpointMiningSuspendDetector(options.suspendDetector);
+            gateSnapshot = {
+                higherRankedCompetitorDomainCount: gate.higherRankedCompetitorDomainCount,
+                dedupedCompetitorDomainCount: gate.dedupedCompetitorDomainCount,
+                mempoolSequenceCacheStatus: gate.mempoolSequenceCacheStatus,
+                lastMempoolSequence: gate.lastMempoolSequence,
+            };
+            if (!gate.allowed) {
+                if (tipKey !== null) {
+                    options.loopState.attemptedTipKey = tipKey;
+                }
+                clearSelectedCandidate(options.loopState);
+                setMiningUiCandidate(options.loopState, best);
+                options.loopState.waitingNote = gate.decision === "suppressed-same-domain-mempool"
+                    ? "Best local sentence found, but a same-domain mempool competitor already matches or beats it."
+                    : gate.decision === "suppressed-top5-mempool"
+                        ? `Best local sentence found, but ${gate.higherRankedCompetitorDomainCount} stronger competitor root domains are already in mempool.`
+                        : "Mining skipped this tick because the mempool competitiveness gate could not be verified safely.";
+                await refreshAndSaveStatus({
+                    paths: options.paths,
+                    provider: options.provider,
+                    readContext: effectiveReadContext,
+                    overrides: {
+                        runMode: options.runMode,
+                        currentPhase: "waiting",
+                        currentPublishDecision: gate.decision,
+                        sameDomainCompetitorSuppressed: gate.sameDomainCompetitorSuppressed,
+                        higherRankedCompetitorDomainCount: gate.higherRankedCompetitorDomainCount,
+                        dedupedCompetitorDomainCount: gate.dedupedCompetitorDomainCount,
+                        competitivenessGateIndeterminate: gate.competitivenessGateIndeterminate,
+                        mempoolSequenceCacheStatus: gate.mempoolSequenceCacheStatus,
+                        lastMempoolSequence: gate.lastMempoolSequence,
+                        lastCompetitivenessGateAtUnixMs: Date.now(),
+                        note: options.loopState.waitingNote,
+                    },
+                    visualizer: options.visualizer,
+                    visualizerState: options.loopState.ui,
+                });
+                await appendEvent(options.paths, createEvent(gate.decision === "suppressed-same-domain-mempool"
+                    ? "publish-skipped-same-domain-mempool"
+                    : gate.decision === "suppressed-top5-mempool"
+                        ? "publish-skipped-top5-mempool"
+                        : "publish-skipped-gate-indeterminate", gate.decision === "suppressed-same-domain-mempool"
+                    ? "Skipped publish because a same-domain mempool competitor already outranks the local candidate."
+                    : gate.decision === "suppressed-top5-mempool"
+                        ? `Skipped publish because ${gate.higherRankedCompetitorDomainCount} stronger competitor root domains are already in mempool.`
+                        : "Skipped publish because the competitiveness gate could not be evaluated safely.", {
+                    targetBlockHeight: best.targetBlockHeight,
+                    referencedBlockHashDisplay: best.referencedBlockHashDisplay,
+                    domainId: best.domainId,
+                    domainName: best.domainName,
+                    score: best.canonicalBlend.toString(),
+                    runId: options.backgroundWorkerRunId,
+                    reason: gate.decision,
+                }));
+                return;
+            }
+        }
+        else {
+            options.loopState.ui.recentWin = null;
+            setMiningUiCandidate(options.loopState, selectedCandidate);
         }
         if (!await ensureCurrentIndexerTruthOrRestart()) {
             return;
@@ -2093,6 +2401,7 @@ async function performMiningCycle(options) {
                     : "Replacing the live mining transaction for the current tip.",
             },
             visualizer: options.visualizer,
+            visualizerState: options.loopState.ui,
         });
         const publishLock = await acquireFileLock(options.paths.walletControlLockPath, {
             purpose: "wallet-mine",
@@ -2105,16 +2414,98 @@ async function performMiningCycle(options) {
             }
             checkpointMiningSuspendDetector(options.suspendDetector);
             const published = await publishCandidate({
-                readContext: effectiveReadContext,
-                candidate: best,
                 dataDir: options.dataDir,
+                databasePath: options.databasePath,
                 provider: options.provider,
                 paths: options.paths,
+                fallbackState: effectiveReadContext.localState.state,
+                openReadContext: options.openReadContext,
                 attachService: options.attachService,
                 rpcFactory: options.rpcFactory,
+                candidate: selectedCandidate,
                 runId: options.backgroundWorkerRunId,
             });
             checkpointMiningSuspendDetector(options.suspendDetector);
+            if (tipKey !== null && published.retryable !== true) {
+                options.loopState.attemptedTipKey = tipKey;
+            }
+            if (published.retryable === true) {
+                cacheSelectedCandidateForTip(options.loopState, tipKey, published.candidate);
+                options.loopState.waitingNote = published.note;
+                await refreshAndSaveStatus({
+                    paths: options.paths,
+                    provider: options.provider,
+                    readContext: {
+                        ...effectiveReadContext,
+                        localState: {
+                            ...effectiveReadContext.localState,
+                            state: published.state,
+                        },
+                    },
+                    overrides: {
+                        runMode: options.runMode,
+                        currentPhase: "waiting",
+                        currentPublishDecision: published.decision,
+                        sameDomainCompetitorSuppressed: false,
+                        higherRankedCompetitorDomainCount: gateSnapshot.higherRankedCompetitorDomainCount,
+                        dedupedCompetitorDomainCount: gateSnapshot.dedupedCompetitorDomainCount,
+                        competitivenessGateIndeterminate: false,
+                        mempoolSequenceCacheStatus: gateSnapshot.mempoolSequenceCacheStatus,
+                        lastMempoolSequence: gateSnapshot.lastMempoolSequence,
+                        lastCompetitivenessGateAtUnixMs: Date.now(),
+                        note: published.note,
+                        livePublishInMempool: published.state.miningState.livePublishInMempool,
+                    },
+                    visualizer: options.visualizer,
+                    visualizerState: options.loopState.ui,
+                });
+                return;
+            }
+            if (published.skipped === true) {
+                clearSelectedCandidate(options.loopState);
+                setMiningUiCandidate(options.loopState, selectedCandidate);
+                options.loopState.waitingNote = published.note;
+                await refreshAndSaveStatus({
+                    paths: options.paths,
+                    provider: options.provider,
+                    readContext: {
+                        ...effectiveReadContext,
+                        localState: {
+                            ...effectiveReadContext.localState,
+                            state: published.state,
+                        },
+                    },
+                    overrides: {
+                        runMode: options.runMode,
+                        currentPhase: "waiting",
+                        currentPublishDecision: published.decision,
+                        sameDomainCompetitorSuppressed: false,
+                        higherRankedCompetitorDomainCount: gateSnapshot.higherRankedCompetitorDomainCount,
+                        dedupedCompetitorDomainCount: gateSnapshot.dedupedCompetitorDomainCount,
+                        competitivenessGateIndeterminate: false,
+                        mempoolSequenceCacheStatus: gateSnapshot.mempoolSequenceCacheStatus,
+                        lastMempoolSequence: gateSnapshot.lastMempoolSequence,
+                        lastCompetitivenessGateAtUnixMs: Date.now(),
+                        note: published.note,
+                        livePublishInMempool: published.state.miningState.livePublishInMempool,
+                    },
+                    visualizer: options.visualizer,
+                    visualizerState: options.loopState.ui,
+                });
+                return;
+            }
+            clearSelectedCandidate(options.loopState);
+            if (published.txid !== null) {
+                options.loopState.ui.latestTxid = published.txid;
+            }
+            setMiningUiCandidate(options.loopState, published.candidate);
+            options.loopState.waitingNote = published.decision === "kept-live-publish"
+                ? "Existing live mining publish already covers this block attempt. Waiting for the next block."
+                : published.txid === null
+                    ? "Mining candidate was evaluated but the existing live publish stayed in place."
+                    : `Mining candidate ${published.decision === "replaced"
+                        ? "replaced"
+                        : "broadcast"} as ${published.txid}. Waiting for the next block.`;
             await refreshAndSaveStatus({
                 paths: options.paths,
                 provider: options.provider,
@@ -2127,25 +2518,20 @@ async function performMiningCycle(options) {
                 },
                 overrides: {
                     runMode: options.runMode,
-                    currentPhase: "publishing",
+                    currentPhase: "waiting",
                     currentPublishDecision: published.decision,
                     sameDomainCompetitorSuppressed: false,
-                    higherRankedCompetitorDomainCount: gate.higherRankedCompetitorDomainCount,
-                    dedupedCompetitorDomainCount: gate.dedupedCompetitorDomainCount,
+                    higherRankedCompetitorDomainCount: gateSnapshot.higherRankedCompetitorDomainCount,
+                    dedupedCompetitorDomainCount: gateSnapshot.dedupedCompetitorDomainCount,
                     competitivenessGateIndeterminate: false,
-                    mempoolSequenceCacheStatus: gate.mempoolSequenceCacheStatus,
-                    lastMempoolSequence: gate.lastMempoolSequence,
+                    mempoolSequenceCacheStatus: gateSnapshot.mempoolSequenceCacheStatus,
+                    lastMempoolSequence: gateSnapshot.lastMempoolSequence,
                     lastCompetitivenessGateAtUnixMs: Date.now(),
-                    note: published.txid === null
-                        ? "Mining candidate was evaluated but the existing live family stayed in place."
-                        : `Mining candidate ${published.decision === "replaced"
-                            ? "replaced"
-                            : published.decision === "fee-bump"
-                                ? "fee-bumped"
-                                : "broadcast"} as ${published.txid}.`,
-                    liveMiningFamilyInMempool: published.state.miningState.liveMiningFamilyInMempool,
+                    note: options.loopState.waitingNote,
+                    livePublishInMempool: published.state.miningState.livePublishInMempool,
                 },
                 visualizer: options.visualizer,
+                visualizerState: options.loopState.ui,
             });
         }
         finally {
@@ -2189,7 +2575,7 @@ async function saveStopSnapshot(options) {
     });
     try {
         let localState = readContext.localState;
-        if (localState.availability === "ready" && localState.state !== null && localState.unlockUntilUnixMs !== null) {
+        if (localState.availability === "ready" && localState.state !== null) {
             const service = await attachOrStartManagedBitcoindService({
                 dataDir: options.dataDir,
                 chain: "main",
@@ -2198,22 +2584,23 @@ async function saveStopSnapshot(options) {
             }).catch(() => null);
             if (service !== null) {
                 const rpc = createRpcClient(service.rpc);
-                const reconciledState = await reconcileLiveMiningState({
+                const reconciledState = (await reconcileLiveMiningState({
                     state: localState.state,
                     rpc,
                     nodeBestHash: readContext.nodeStatus?.nodeBestHashHex ?? null,
                     nodeBestHeight: readContext.nodeStatus?.nodeBestHeight ?? null,
-                });
+                    snapshotState: readContext.snapshot?.state ?? null,
+                })).state;
                 const stopState = defaultMiningStatePatch(reconciledState, {
                     runMode: "stopped",
-                    state: reconciledState.miningState.liveMiningFamilyInMempool
+                    state: reconciledState.miningState.livePublishInMempool
                         ? reconciledState.miningState.state === "paused-stale"
                             ? "paused-stale"
                             : "paused"
                         : reconciledState.miningState.state === "repair-required"
                             ? "repair-required"
                             : "idle",
-                    pauseReason: reconciledState.miningState.liveMiningFamilyInMempool
+                    pauseReason: reconciledState.miningState.livePublishInMempool
                         ? reconciledState.miningState.state === "paused-stale"
                             ? "stale-block-context"
                             : "user-stopped"
@@ -2224,8 +2611,6 @@ async function saveStopSnapshot(options) {
                 await saveWalletStatePreservingUnlock({
                     state: stopState,
                     provider: options.provider,
-                    unlockUntilUnixMs: localState.unlockUntilUnixMs,
-                    nowUnixMs: Date.now(),
                     paths: options.paths,
                 });
                 localState = {
@@ -2270,6 +2655,7 @@ async function attemptSaveMempool(rpc, paths, runId) {
 }
 async function runMiningLoop(options) {
     const suspendDetector = createMiningSuspendDetector();
+    const loopState = createMiningLoopState();
     await appendEvent(options.paths, createEvent("runtime-start", `Started ${options.runMode} mining runtime.`, {
         runId: options.backgroundWorkerRunId,
     }));
@@ -2298,6 +2684,7 @@ async function runMiningLoop(options) {
         await performMiningCycle({
             ...options,
             suspendDetector,
+            loopState,
         });
         await sleep(Math.min(MINING_LOOP_INTERVAL_MS, MINING_STATUS_HEARTBEAT_INTERVAL_MS), options.signal);
     }
@@ -2487,7 +2874,7 @@ export async function stopBackgroundMining(options) {
             runMode: "background",
             backgroundWorkerPid: snapshot.backgroundWorkerPid,
             backgroundWorkerRunId: snapshot.backgroundWorkerRunId,
-            note: snapshot.liveMiningFamilyInMempool
+            note: snapshot.livePublishInMempool
                 ? "Background mining stopped. The last mining transaction may still confirm from mempool."
                 : "Background mining stopped.",
         });
@@ -2569,8 +2956,11 @@ export async function handleDetectedMiningRuntimeResumeForTesting(options) {
     await handleDetectedMiningRuntimeResume(options);
 }
 export async function performMiningCycleForTesting(options) {
-    await performMiningCycle(options);
+    await performMiningCycle({
+        ...options,
+        loopState: options.loopState ?? createMiningLoopState(),
+    });
 }
-export function shouldTreatCandidateAsFeeBumpForTesting(options) {
-    return candidateNeedsFeeMaintenance(options);
+export function shouldKeepCurrentTipLivePublishForTesting(options) {
+    return livePublishTargetsCandidateTip(options);
 }