@cogcoin/client 1.1.6 → 1.1.7

package/dist/cli/preview-json.d.ts

@@ -1,6 +1,6 @@
 import type { AnchorDomainResult, CogMutationResult, DomainAdminMutationResult, DomainMarketMutationResult, FieldMutationResult, RegisterDomainResult, ReputationMutationResult, WalletMutationFeeSummary } from "../wallet/tx/index.js";
 import type { WalletRepairResult, WalletResetPreview } from "../wallet/lifecycle.js";
-import type { MiningControlPlaneView, MiningRuntimeStatusV1 } from "../wallet/mining/index.js";
+import type { MiningControlPlaneView } from "../wallet/mining/index.js";
 export declare function buildSingleTxMutationPreviewData(options: {
     kind: string;
     localStatus: string;
@@ -317,24 +317,3 @@ export declare function buildMineSetupPreviewData(view: MiningControlPlaneView):
     };
     state: Record<string, unknown>;
 };
-export declare function buildMineStartPreviewData(result: {
-    started: boolean;
-    snapshot: MiningRuntimeStatusV1 | null;
-}): {
-    resultType: "state-change";
-    stateChange: {
-        kind: string;
-        before: Record<string, unknown> | null;
-        after: Record<string, unknown> | null;
-    };
-    state: Record<string, unknown>;
-};
-export declare function buildMineStopPreviewData(snapshot: MiningRuntimeStatusV1 | null): {
-    resultType: "state-change";
-    stateChange: {
-        kind: string;
-        before: Record<string, unknown> | null;
-        after: Record<string, unknown> | null;
-    };
-    state: Record<string, unknown>;
-};

package/dist/cli/preview-json.js

@@ -252,22 +252,3 @@ export function buildMineSetupPreviewData(view) {
         },
     });
 }
-export function buildMineStartPreviewData(result) {
-    return buildStateChangePreviewData({
-        kind: "mine-start",
-        state: {
-            started: result.started,
-            runtime: summarizeRuntime(result.snapshot),
-        },
-    });
-}
-export function buildMineStopPreviewData(snapshot) {
-    return buildStateChangePreviewData({
-        kind: "mine-stop",
-        state: {
-            stopped: snapshot !== null,
-            runtime: summarizeRuntime(snapshot),
-            note: snapshot?.note ?? "Background mining was not active.",
-        },
-    });
-}

package/dist/cli/types.d.ts

@@ -11,7 +11,7 @@ import type { WalletPrompter, initializeWallet, previewResetWallet, repairWallet
 import type { openWalletReadContext } from "../wallet/read/index.js";
 import { loadRawWalletStateEnvelope, loadWalletState } from "../wallet/state/storage.js";
 import type { WalletSecretProvider } from "../wallet/state/provider.js";
-import type { ensureBuiltInMiningSetupIfNeeded, followMiningLog, inspectMiningControlPlane, inspectMiningDomainPromptState, readMiningLog, runForegroundMining, setupBuiltInMining, startBackgroundMining, stopBackgroundMining, updateMiningDomainPrompt } from "../wallet/mining/index.js";
+import type { ensureBuiltInMiningSetupIfNeeded, followMiningLog, inspectMiningControlPlane, inspectMiningDomainPromptState, readMiningLog, runForegroundMining, setupBuiltInMining, updateMiningDomainPrompt } from "../wallet/mining/index.js";
 import type { anchorDomain, transferBitcoin, buyDomain, claimCogLock, clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, clearField, createField, giveReputation, lockCogToDomain, registerDomain, reclaimCogLock, revokeReputation, sendCog, setField, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, sellDomain, transferDomain } from "../wallet/tx/index.js";
 import type { CommandHandlerFamily, CommandName } from "./command-registry.js";
 export type { CommandHandlerFamily, CommandName } from "./command-registry.js";
@@ -154,8 +154,6 @@ export interface CliRunnerContext {
     inspectMiningDomainPromptState?: typeof inspectMiningDomainPromptState;
     ensureBuiltInMiningSetupIfNeeded?: typeof ensureBuiltInMiningSetupIfNeeded;
     runForegroundMining?: typeof runForegroundMining;
-    startBackgroundMining?: typeof startBackgroundMining;
-    stopBackgroundMining?: typeof stopBackgroundMining;
     setupBuiltInMining?: typeof setupBuiltInMining;
     updateMiningDomainPrompt?: typeof updateMiningDomainPrompt;
     readMiningLog?: typeof readMiningLog;

package/dist/cli/wallet-format.js

@@ -115,7 +115,7 @@ export function getRepairRecommendation(context) {
 }
 export function getClientUnlockRecommendation(context) {
     if (context.localState.unlockRequired) {
-        return "Run `cogcoin client unlock` to temporarily unlock wallet-local secrets.";
+        return "Rerun this command in an interactive terminal so Cogcoin can prompt for the client password.";
     }
     return null;
 }

package/dist/cli/workflow-hints.d.ts

@@ -3,12 +3,11 @@ export declare function formatNextStepLines(nextSteps: readonly string[]): strin
 export declare function getFundingQuickstartGuidance(): string;
 export declare function getInitNextSteps(): string[];
 export declare function getRestoreNextSteps(): string[];
-export declare function getSetupUnlockGuidanceLines(unlockSeconds: number): string[];
+export declare function getInitUnlockGuidanceLines(): string[];
 export declare function getBootstrapSyncNextStep(context: Pick<WalletReadContext, "bitcoind" | "indexer" | "nodeHealth">): string | null;
 export declare function getRegisterNextSteps(domainName: string, registerKind: "root" | "subdomain"): string[];
 export declare function getAnchorNextSteps(domainName: string): string[];
 export declare function getMineSetupNextSteps(): string[];
-export declare function getMineStopNextSteps(): string[];
 export declare function getAddressNextSteps(context: Pick<WalletReadContext, "bitcoind" | "indexer" | "nodeHealth">, address: string | null | undefined): string[];
 export declare function getIdsNextSteps(walletAddress: string | null | undefined): string[];
 export declare function getLocksNextSteps(locks: readonly WalletLockView[] | null | undefined): string[];

package/dist/cli/workflow-hints.js

@@ -13,10 +13,10 @@ export function getInitNextSteps() {
 export function getRestoreNextSteps() {
     return ["cogcoin sync", "cogcoin address"];
 }
-export function getSetupUnlockGuidanceLines(unlockSeconds) {
+export function getInitUnlockGuidanceLines() {
     return [
-        `Client unlock: active for ${unlockSeconds} seconds.`,
-        "Use `cogcoin client unlock` to lengthen this unlock window, or `cogcoin client lock` to lock immediately.",
+        "Client password reuse stays active in memory for the rest of this long-running init command, up to about 24 hours.",
+        "Future Cogcoin commands will prompt again when they need wallet-local secrets.",
     ];
 }
 function blocksSyncBootstrap(context) {
@@ -52,15 +52,12 @@ export function getRegisterNextSteps(domainName, registerKind) {
 export function getAnchorNextSteps(domainName) {
     const nextSteps = [`cogcoin show ${domainName}`];
     if (isRootDomainName(domainName)) {
-        nextSteps.push("cogcoin mine", "cogcoin mine start");
+        nextSteps.push("cogcoin mine");
     }
     return nextSteps;
 }
 export function getMineSetupNextSteps() {
-    return ["cogcoin mine", "cogcoin mine start"];
-}
-export function getMineStopNextSteps() {
-    return ["cogcoin mine log"];
+    return ["cogcoin mine"];
 }
 export function getAddressNextSteps(context, address) {
     if (address === null || address === undefined || address.length === 0) {

package/dist/wallet/lifecycle/context.js

@@ -47,7 +47,6 @@ export function resolveWalletRepairContext(options) {
         attachIndexerDaemon: options.attachIndexerDaemon ?? attachOrStartIndexerDaemon,
         probeIndexerDaemon: options.probeIndexerDaemon ?? probeIndexerDaemon,
         requestMiningPreemption: options.requestMiningPreemption,
-        startBackgroundMining: options.startBackgroundMining,
     };
 }
 export async function acquireWalletControlLock(paths, purpose) {

package/dist/wallet/lifecycle/repair-mining.d.ts

@@ -2,8 +2,7 @@ import type { MiningRuntimeStatusV1 } from "../mining/types.js";
 import type { WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import type { WalletStateV1 } from "../types.js";
-import type { WalletPrompter, WalletRepairResult } from "./types.js";
-export declare function createSilentNonInteractivePrompter(): WalletPrompter;
+import type { WalletRepairResult } from "./types.js";
 export declare function applyRepairStoppedMiningState(state: WalletStateV1): WalletStateV1;
 export declare function createStoppedMiningRuntimeSnapshotForRepair(options: {
     state: WalletStateV1;
@@ -39,9 +38,6 @@ export declare function resumeBackgroundMiningAfterRepair(options: {
     repairedState: WalletStateV1;
     bitcoindPostRepairHealth: WalletRepairResult["bitcoindPostRepairHealth"];
     indexerPostRepairHealth: WalletRepairResult["indexerPostRepairHealth"];
-    dataDir: string;
-    databasePath: string;
-    startBackgroundMining?: typeof import("../mining/runner.js").startBackgroundMining;
 }): Promise<{
     miningResumeAction: WalletRepairResult["miningResumeAction"];
     miningPostRepairRunMode: WalletRepairResult["miningPostRepairRunMode"];

package/dist/wallet/lifecycle/repair-mining.js

@@ -8,15 +8,6 @@ import { normalizeMiningStateRecord } from "../mining/state.js";
 import { createWalletSecretReference } from "../state/provider.js";
 import { persistWalletStateUpdate } from "../descriptor-normalization.js";
 import { isProcessAlive, stopRecordedManagedProcess } from "./repair-runtime.js";
-export function createSilentNonInteractivePrompter() {
-    return {
-        isInteractive: false,
-        writeLine() { },
-        async prompt() {
-            return "";
-        },
-    };
-}
 export function applyRepairStoppedMiningState(state) {
     const miningState = normalizeMiningStateRecord(state.miningState);
     return {
@@ -271,34 +262,9 @@ export async function resumeBackgroundMiningAfterRepair(options) {
             miningResumeError: null,
         };
     }
-    try {
-        const startBackgroundMining = options.startBackgroundMining
-            ?? (await import("../mining/runner.js")).startBackgroundMining;
-        const resumed = await startBackgroundMining({
-            dataDir: options.dataDir,
-            databasePath: options.databasePath,
-            provider: options.provider,
-            paths: options.paths,
-            prompter: createSilentNonInteractivePrompter(),
-        });
-        if (resumed.snapshot?.runMode === "background") {
-            return {
-                miningResumeAction: "resumed-background",
-                miningPostRepairRunMode: "background",
-                miningResumeError: null,
-            };
-        }
-        return {
-            miningResumeAction: "resume-failed",
-            miningPostRepairRunMode: "stopped",
-            miningResumeError: "Background mining did not report a background runtime after repair.",
-        };
-    }
-    catch (error) {
-        return {
-            miningResumeAction: "resume-failed",
-            miningPostRepairRunMode: "stopped",
-            miningResumeError: error instanceof Error ? error.message : String(error),
-        };
-    }
+    return {
+        miningResumeAction: "skipped-background-mode-removed",
+        miningPostRepairRunMode: "stopped",
+        miningResumeError: null,
+    };
 }

package/dist/wallet/lifecycle/repair.js

@@ -95,9 +95,6 @@ export async function repairWallet(options) {
             repairedState,
             bitcoindPostRepairHealth: bitcoindStage.bitcoindPostRepairHealth,
             indexerPostRepairHealth: indexerStage.indexerPostRepairHealth,
-            dataDir: context.dataDir,
-            databasePath: context.databasePath,
-            startBackgroundMining: context.startBackgroundMining,
         });
         await clearLegacyWalletLockArtifacts(context.paths.walletRuntimeRoot);
         return {

package/dist/wallet/lifecycle/setup.js

@@ -1,5 +1,6 @@
 import { deriveWalletMaterialFromMnemonic } from "../material.js";
 import { ensureClientPasswordConfigured, withInteractiveWalletSecretProvider, } from "../state/provider.js";
+import { bindClientPasswordPromptSessionPolicy } from "../state/client-password/session-policy.js";
 import { loadWalletStateForAccess, mapWalletReadAccessError } from "./access.js";
 import { acquireWalletControlLock, resolveWalletManagedCoreContext, resolveWalletSetupContext, walletStateExists, } from "./context.js";
 import { clearSensitiveDisplay, confirmMnemonic, confirmTypedAcknowledgement, promptForInitializationMode, promptForRestoreMnemonic, writeMnemonicReveal, } from "./setup-prompts.js";
@@ -9,10 +10,11 @@ export async function initializeWallet(options) {
     if (!context.prompter.isInteractive) {
         throw new Error("wallet_init_requires_tty");
     }
-    const interactiveProvider = withInteractiveWalletSecretProvider(context.provider, context.prompter);
+    const initPrompter = bindClientPasswordPromptSessionPolicy(context.prompter, "init-24h");
+    const interactiveProvider = withInteractiveWalletSecretProvider(context.provider, initPrompter);
     const controlLock = await acquireWalletControlLock(context.paths, "wallet-init");
     try {
-        const passwordAction = await ensureClientPasswordConfigured(context.provider, context.prompter);
+        const passwordAction = await ensureClientPasswordConfigured(context.provider, initPrompter);
         if (await walletStateExists(context.paths)) {
             await clearPendingInitialization(context.paths, interactiveProvider);
             const loaded = await loadWalletStateForAccess({
@@ -29,7 +31,7 @@ export async function initializeWallet(options) {
                 state: loaded.state,
             };
         }
-        const setupMode = await promptForInitializationMode(context.prompter);
+        const setupMode = await promptForInitializationMode(initPrompter);
         let material;
         if (setupMode === "generated") {
             material = await loadOrCreatePendingInitializationMaterial({
@@ -37,26 +39,26 @@ export async function initializeWallet(options) {
                 paths: context.paths,
                 nowUnixMs: context.nowUnixMs,
             });
-            writeMnemonicReveal(context.prompter, material.mnemonic.phrase, [
+            writeMnemonicReveal(initPrompter, material.mnemonic.phrase, [
                 "Cogcoin Wallet Initialization",
                 "Write down this 24-word recovery phrase.",
                 "The same phrase will be shown again until confirmation succeeds:",
                 "",
             ]);
             try {
-                await confirmMnemonic(context.prompter, material.mnemonic.words);
+                await confirmMnemonic(initPrompter, material.mnemonic.words);
             }
             finally {
-                await clearSensitiveDisplay(context.prompter, "mnemonic-reveal");
+                await clearSensitiveDisplay(initPrompter, "mnemonic-reveal");
             }
         }
         else {
             let mnemonicPhrase;
             try {
-                mnemonicPhrase = await promptForRestoreMnemonic(context.prompter);
+                mnemonicPhrase = await promptForRestoreMnemonic(initPrompter);
             }
             finally {
-                await clearSensitiveDisplay(context.prompter, "restore-mnemonic-entry");
+                await clearSensitiveDisplay(initPrompter, "restore-mnemonic-entry");
             }
             await clearPendingInitialization(context.paths, interactiveProvider);
             material = deriveWalletMaterialFromMnemonic(mnemonicPhrase);

package/dist/wallet/lifecycle/types.d.ts

@@ -3,7 +3,6 @@ import type { createRpcClient } from "../../bitcoind/node.js";
 import type { attachOrStartManagedBitcoindService, probeManagedBitcoindService } from "../../bitcoind/service.js";
 import type { RpcListUnspentEntry } from "../../bitcoind/types.js";
 import type { requestMiningGenerationPreemption } from "../mining/coordination.js";
-import type { startBackgroundMining } from "../mining/runner.js";
 import type { WalletRuntimePaths } from "../runtime.js";
 import type { WalletSecretProvider } from "../state/provider.js";
 import type { WalletStateV1 } from "../types.js";
@@ -45,7 +44,7 @@ export interface WalletRepairResult {
     indexerCompatibilityIssue: "none" | "service-version-mismatch" | "wallet-root-mismatch" | "schema-mismatch";
     indexerPostRepairHealth: "starting" | "catching-up" | "synced" | "failed";
     miningPreRepairRunMode: "stopped" | "foreground" | "background";
-    miningResumeAction: "none" | "skipped-not-resumable" | "skipped-post-repair-blocked" | "resumed-background" | "resume-failed";
+    miningResumeAction: "none" | "skipped-not-resumable" | "skipped-post-repair-blocked" | "skipped-background-mode-removed";
     miningPostRepairRunMode: "stopped" | "background";
     miningResumeError: string | null;
     note: string | null;
@@ -127,7 +126,6 @@ export interface WalletRepairDependencies extends WalletManagedCoreDependencies
     attachIndexerDaemon?: typeof attachOrStartIndexerDaemon;
     probeIndexerDaemon?: typeof probeIndexerDaemon;
     requestMiningPreemption?: typeof requestMiningGenerationPreemption;
-    startBackgroundMining?: typeof startBackgroundMining;
 }
 export interface WalletRepairContext extends WalletManagedCoreContext {
     dataDir: string;
@@ -137,7 +135,6 @@ export interface WalletRepairContext extends WalletManagedCoreContext {
     attachIndexerDaemon: NonNullable<WalletRepairDependencies["attachIndexerDaemon"]>;
     probeIndexerDaemon: NonNullable<WalletRepairDependencies["probeIndexerDaemon"]>;
     requestMiningPreemption?: WalletRepairDependencies["requestMiningPreemption"];
-    startBackgroundMining?: WalletRepairDependencies["startBackgroundMining"];
 }
 export interface WalletBitcoindRepairStageResult {
     state: WalletStateV1;

package/dist/wallet/managed-core-wallet.d.ts

@@ -8,6 +8,8 @@ export declare function withUnlockedManagedCoreWallet<T>(options: {
     walletName: string;
     internalPassphrase: string;
     timeoutSeconds?: number;
+    recoverLockedWalletOnce?: boolean;
+    onLockedWalletRecoveryOutcome?: (outcome: "recovered" | "still-locked") => void;
     run: () => Promise<T>;
 }): Promise<T>;
 export declare function clearLegacyWalletLockArtifacts(walletRuntimeRoot: string): Promise<void>;

package/dist/wallet/managed-core-wallet.js

@@ -3,10 +3,36 @@ import { join } from "node:path";
 export const MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS = 10;
 const LEGACY_UNLOCK_SESSION_FILENAME = "wallet-unlock-session.enc";
 const LEGACY_EXPLICIT_LOCK_FILENAME = "wallet-explicit-lock.json";
+const MANAGED_CORE_WALLET_PROCESS_PSBT_LOCKED_ERROR_PREFIX = "bitcoind_rpc_walletprocesspsbt_-13_";
+const MANAGED_CORE_WALLET_PROCESS_PSBT_LOCKED_ERROR_SUFFIX = "Please enter the wallet passphrase with walletpassphrase first.";
+function isManagedCoreWalletProcessPsbtLockedError(error) {
+    return error instanceof Error
+        && error.message.startsWith(MANAGED_CORE_WALLET_PROCESS_PSBT_LOCKED_ERROR_PREFIX)
+        && error.message.endsWith(MANAGED_CORE_WALLET_PROCESS_PSBT_LOCKED_ERROR_SUFFIX);
+}
 export async function withUnlockedManagedCoreWallet(options) {
     await options.rpc.walletPassphrase(options.walletName, options.internalPassphrase, options.timeoutSeconds ?? MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS);
     try {
-        return await options.run();
+        try {
+            return await options.run();
+        }
+        catch (error) {
+            if (!options.recoverLockedWalletOnce || !isManagedCoreWalletProcessPsbtLockedError(error)) {
+                throw error;
+            }
+            await options.rpc.walletPassphrase(options.walletName, options.internalPassphrase, options.timeoutSeconds ?? MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS);
+            try {
+                const result = await options.run();
+                options.onLockedWalletRecoveryOutcome?.("recovered");
+                return result;
+            }
+            catch (retryError) {
+                if (isManagedCoreWalletProcessPsbtLockedError(retryError)) {
+                    options.onLockedWalletRecoveryOutcome?.("still-locked");
+                }
+                throw retryError;
+            }
+        }
     }
     finally {
         await options.rpc.walletLock(options.walletName).catch(() => undefined);

package/dist/wallet/mining/candidate.d.ts

@@ -56,5 +56,6 @@ export declare function generateCandidatesForDomains(options: {
     indexerTruthKey: IndexerTruthKey | null;
     runId?: string | null;
     fetchImpl?: typeof fetch;
+    signal?: AbortSignal;
 }): Promise<MiningCandidate[]>;
 export declare function chooseBestLocalCandidate(candidates: MiningCandidate[]): Promise<MiningCandidate | null>;

package/dist/wallet/mining/candidate.js

@@ -5,6 +5,7 @@ import { loadClientConfig } from "./config.js";
 import { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, } from "./coordination.js";
 import { createMiningSentenceRequestLimits } from "./sentence-protocol.js";
 import { generateMiningSentences } from "./sentences.js";
+import { createMiningStopRequestedError } from "./stop.js";
 import { isMineableWalletDomain } from "../read/index.js";
 import { lookupDomain } from "@cogcoin/indexer/queries";
 const BEST_BLOCK_POLL_INTERVAL_MS = 500;
@@ -142,6 +143,11 @@ export async function generateCandidatesForDomains(options) {
     let stale = false;
     let staleIndexerTruth = false;
     let preempted = false;
+    let stopRequested = false;
+    const handleStop = () => {
+        stopRequested = true;
+        abortController.abort(options.signal?.reason ?? createMiningStopRequestedError());
+    };
     const timer = setInterval(async () => {
         try {
             const [current, truthCurrent] = await Promise.all([
@@ -171,6 +177,12 @@ export async function generateCandidatesForDomains(options) {
         }
     }, BEST_BLOCK_POLL_INTERVAL_MS);
     try {
+        if (options.signal?.aborted) {
+            handleStop();
+        }
+        else {
+            options.signal?.addEventListener("abort", handleStop, { once: true });
+        }
         await markMiningGenerationActive({
             paths: options.paths,
             runId: options.runId ?? null,
@@ -185,12 +197,26 @@ export async function generateCandidatesForDomains(options) {
         });
         let generated;
         try {
-            generated = await generateMiningSentences(generationRequest, {
-                paths: options.paths,
-                provider: options.provider,
-                signal: abortController.signal,
-                fetchImpl: options.fetchImpl,
-            });
+            generated = await Promise.race([
+                generateMiningSentences(generationRequest, {
+                    paths: options.paths,
+                    provider: options.provider,
+                    signal: abortController.signal,
+                    fetchImpl: options.fetchImpl,
+                }),
+                new Promise((_resolve, reject) => {
+                    const handleAbort = () => {
+                        reject(abortController.signal.reason instanceof Error
+                            ? abortController.signal.reason
+                            : createMiningStopRequestedError());
+                    };
+                    if (abortController.signal.aborted) {
+                        handleAbort();
+                        return;
+                    }
+                    abortController.signal.addEventListener("abort", handleAbort, { once: true });
+                }),
+            ]);
         }
         catch (error) {
             if (stale) {
@@ -202,6 +228,11 @@ export async function generateCandidatesForDomains(options) {
             if (preempted) {
                 throw new Error("mining_generation_preempted");
             }
+            if (stopRequested || options.signal?.aborted) {
+                throw options.signal?.reason instanceof Error
+                    ? options.signal.reason
+                    : createMiningStopRequestedError();
+            }
             throw error;
         }
         if (stale) {
@@ -253,6 +284,7 @@ export async function generateCandidatesForDomains(options) {
     }
     finally {
         clearInterval(timer);
+        options.signal?.removeEventListener("abort", handleStop);
         await markMiningGenerationInactive({
             paths: options.paths,
             runId: options.runId ?? null,

package/dist/wallet/mining/competitiveness.d.ts

@@ -19,4 +19,5 @@ export declare function runCompetitivenessGate(options: {
     assaySentencesImpl?: typeof assaySentences;
     cooperativeYield?: MiningCooperativeYield;
     cooperativeYieldEvery?: number;
+    throwIfStopping?: () => void;
 }): Promise<CompetitivenessDecision>;

package/dist/wallet/mining/competitiveness.js

@@ -371,6 +371,7 @@ export async function runCompetitivenessGate(options) {
     let mempoolVerbose;
     try {
         mempoolVerbose = await options.rpc.getRawMempoolVerbose();
+        options.throwIfStopping?.();
     }
     catch {
         return createDecision({
@@ -415,6 +416,7 @@ export async function runCompetitivenessGate(options) {
             cooperativeYield: options.cooperativeYield,
             cooperativeYieldEvery: options.cooperativeYieldEvery,
         });
+        options.throwIfStopping?.();
         const txid = visibleTxids[index];
         if (txContexts.has(txid)) {
             continue;
@@ -423,6 +425,7 @@ export async function runCompetitivenessGate(options) {
             options.rpc.getRawTransaction(txid, true).catch(() => null),
             options.rpc.getMempoolEntry(txid).catch(() => null),
         ]);
+        options.throwIfStopping?.();
         if (tx === null || mempoolEntry === null) {
             continue;
         }
@@ -447,6 +450,7 @@ export async function runCompetitivenessGate(options) {
             cooperativeYield: options.cooperativeYield,
             cooperativeYieldEvery: options.cooperativeYieldEvery,
         });
+        options.throwIfStopping?.();
         const txid = visibleTxids[index];
         const context = txContexts.get(txid);
         if (context === undefined || context.payload === null || context.senderScriptHex === null) {
@@ -463,6 +467,7 @@ export async function runCompetitivenessGate(options) {
             domainId: decoded.domainId,
             senderScriptHex: context.senderScriptHex,
         });
+        options.throwIfStopping?.();
         if (overlayDomain === "indeterminate") {
             const decision = createDecision({
                 competitivenessGateIndeterminate: true,
@@ -487,6 +492,7 @@ export async function runCompetitivenessGate(options) {
             continue;
         }
         const assayed = await assaySentencesImpl(decoded.domainId, options.candidate.referencedBlockHashInternal, [Buffer.from(decoded.sentenceBytes).toString("utf8")]).catch(() => []);
+        options.throwIfStopping?.();
         const scored = assayed[0];
         if (scored === undefined || !scored.gatesPass || scored.encodedSentenceBytes === null || scored.canonicalBlend === null) {
             continue;

package/dist/wallet/mining/cycle.d.ts

@@ -27,6 +27,7 @@ export declare function runMiningPhaseMachine(options: {
     attachService: typeof attachOrStartManagedBitcoindService;
     rpcFactory: (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
     fetchImpl?: typeof fetch;
+    stopSignal?: AbortSignal;
     generateCandidatesForDomainsImpl?: typeof generateCandidatesForDomains;
     runCompetitivenessGateImpl?: typeof runCompetitivenessGate;
     assaySentencesImpl?: typeof assaySentences;
@@ -35,5 +36,6 @@ export declare function runMiningPhaseMachine(options: {
     nowImpl?: () => number;
     saveCycleStatus: (readContext: WalletReadContext, overrides: MiningRuntimeStatusOverrides) => Promise<MiningRuntimeStatusV1>;
     appendEvent: (event: MiningEventRecord) => Promise<void>;
+    throwIfStopping?: () => void;
     throwIfSuspendDetected?: () => void;
 }): Promise<void>;

package/dist/wallet/mining/cycle.js

@@ -59,7 +59,12 @@ export async function runMiningPhaseMachine(options) {
             return false;
         }
     };
+    const throwIfInterrupted = () => {
+        options.throwIfSuspendDetected?.();
+        options.throwIfStopping?.();
+    };
     while (true) {
+        throwIfInterrupted();
         switch (state.phase) {
             case "idle": {
                 if (options.corePublishState !== "healthy") {
@@ -198,8 +203,9 @@ export async function runMiningPhaseMachine(options) {
                         indexerTruthKey,
                         runId: options.backgroundWorkerRunId,
                         fetchImpl: options.fetchImpl,
+                        signal: options.stopSignal,
                     });
-                    options.throwIfSuspendDetected?.();
+                    throwIfInterrupted();
                 }
                 catch (error) {
                     if (error instanceof MiningProviderRequestError) {
@@ -341,8 +347,9 @@ export async function runMiningPhaseMachine(options) {
                     assaySentencesImpl: options.assaySentencesImpl,
                     cooperativeYield: options.cooperativeYieldImpl,
                     cooperativeYieldEvery: options.cooperativeYieldEvery,
+                    throwIfStopping: options.throwIfStopping,
                 });
-                options.throwIfSuspendDetected?.();
+                throwIfInterrupted();
                 state.gateSnapshot = {
                     higherRankedCompetitorDomainCount: gate.higherRankedCompetitorDomainCount,
                     dedupedCompetitorDomainCount: gate.dedupedCompetitorDomainCount,
@@ -421,7 +428,7 @@ export async function runMiningPhaseMachine(options) {
                     if (!await ensureCurrentIndexerTruthOrRestart()) {
                         return;
                     }
-                    options.throwIfSuspendDetected?.();
+                    throwIfInterrupted();
                     const published = await publishCandidate({
                         dataDir: options.dataDir,
                         databasePath: options.databasePath,
@@ -436,6 +443,7 @@ export async function runMiningPhaseMachine(options) {
                         appendEventFn: async (_paths, event) => {
                             await options.appendEvent(event);
                         },
+                        throwIfStopping: options.throwIfStopping,
                     });
                     if (state.tipKey !== null
                         && published.retryable !== true
@@ -462,6 +470,7 @@ export async function runMiningPhaseMachine(options) {
                             mempoolSequenceCacheStatus: state.gateSnapshot.mempoolSequenceCacheStatus,
                             lastMempoolSequence: state.gateSnapshot.lastMempoolSequence,
                             lastCompetitivenessGateAtUnixMs: now(),
+                            lastError: published.lastError ?? null,
                             note: published.note,
                             livePublishInMempool: published.state.miningState.livePublishInMempool,
                         });
@@ -473,7 +482,7 @@ export async function runMiningPhaseMachine(options) {
                         options.loopState.waitingNote = published.note;
                         const lastError = published.decision === "publish-paused-insufficient-funds"
                             ? published.lastError ?? createInsufficientFundsMiningPublishErrorMessage()
-                            : undefined;
+                            : null;
                         await options.saveCycleStatus({
                             ...options.readContext,
                             localState: {
@@ -526,6 +535,7 @@ export async function runMiningPhaseMachine(options) {
                         mempoolSequenceCacheStatus: state.gateSnapshot.mempoolSequenceCacheStatus,
                         lastMempoolSequence: state.gateSnapshot.lastMempoolSequence,
                         lastCompetitivenessGateAtUnixMs: now(),
+                        lastError: null,
                         note: options.loopState.waitingNote,
                         livePublishInMempool: published.state.miningState.livePublishInMempool,
                     });

package/dist/wallet/mining/engine-types.d.ts

@@ -103,6 +103,7 @@ export interface MiningPublishRetryResult {
     txid: null;
     decision: "publish-retry-pending";
     note: string;
+    lastError?: string | null;
     skipped?: false;
     retryable: true;
     candidate: MiningCandidate;

package/dist/wallet/mining/index.d.ts

@@ -1,7 +1,7 @@
 export { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
 export { canonicalizeMiningDomainPromptName, inspectMiningDomainPromptState, updateMiningDomainPrompt, } from "./domain-prompts.js";
 export { followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
-export { ensureBuiltInMiningSetupIfNeeded, runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, type MiningStartResult, } from "./runner.js";
+export { ensureBuiltInMiningSetupIfNeeded, runForegroundMining, } from "./runner.js";
 export { appendMiningEvent, loadMiningRuntimeStatus, readMiningEvents, resolveRotatedMiningEventsPath, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
 export type { MiningSentenceCandidateV1, MiningSentenceGenerationRequestV1, MiningSentenceGenerationResponseV1, } from "./sentence-protocol.js";
 export { loadClientConfig, saveBuiltInMiningProviderConfig, saveClientConfig, } from "./config.js";

package/dist/wallet/mining/index.js

@@ -1,6 +1,6 @@
 export { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
 export { canonicalizeMiningDomainPromptName, inspectMiningDomainPromptState, updateMiningDomainPrompt, } from "./domain-prompts.js";
 export { followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
-export { ensureBuiltInMiningSetupIfNeeded, runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, } from "./runner.js";
+export { ensureBuiltInMiningSetupIfNeeded, runForegroundMining, } from "./runner.js";
 export { appendMiningEvent, loadMiningRuntimeStatus, readMiningEvents, resolveRotatedMiningEventsPath, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
 export { loadClientConfig, saveBuiltInMiningProviderConfig, saveClientConfig, } from "./config.js";