@cogcoin/client 0.5.14 → 1.0.0

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

@@ -0,0 +1,13 @@
+export declare const MANAGED_CORE_WALLET_UNLOCK_TIMEOUT_SECONDS = 10;
+export interface ManagedCoreWalletUnlockingRpc {
+    walletPassphrase(walletName: string, passphrase: string, timeoutSeconds: number): Promise<null>;
+    walletLock(walletName: string): Promise<null>;
+}
+export declare function withUnlockedManagedCoreWallet<T>(options: {
+    rpc: ManagedCoreWalletUnlockingRpc;
+    walletName: string;
+    internalPassphrase: string;
+    timeoutSeconds?: number;
+    run: () => Promise<T>;
+}): Promise<T>;
+export declare function clearLegacyWalletLockArtifacts(walletRuntimeRoot: string): Promise<void>;

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

@@ -0,0 +1,20 @@
+import { rm } from "node:fs/promises";
+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";
+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();
+    }
+    finally {
+        await options.rpc.walletLock(options.walletName).catch(() => undefined);
+    }
+}
+export async function clearLegacyWalletLockArtifacts(walletRuntimeRoot) {
+    await Promise.all([
+        rm(join(walletRuntimeRoot, LEGACY_UNLOCK_SESSION_FILENAME), { force: true }).catch(() => undefined),
+        rm(join(walletRuntimeRoot, LEGACY_EXPLICIT_LOCK_FILENAME), { force: true }).catch(() => undefined),
+    ]);
+}

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

@@ -8,17 +8,10 @@ export declare const MINING_PROVIDER_BACKOFF_BASE_MS = 30000;
 export declare const MINING_PROVIDER_BACKOFF_MAX_MS = 900000;
 export declare const MINING_LOOP_INTERVAL_MS = 2000;
 export declare const MINING_BUILTIN_TIMEOUT_MS = 30000;
-export declare const MINING_HOOK_SCHEMA_VERSION: 1;
-export declare const MINING_HOOK_MAX_CANDIDATE_SENTENCE_UTF8_BYTES = 512;
-export declare const MINING_HOOK_MAX_CANDIDATES_PER_ROOT_DOMAIN = 8;
-export declare const MINING_HOOK_MAX_CANDIDATES_TOTAL = 64;
-export declare const MINING_HOOK_TIMEOUT_MS = 30000;
-export declare const MINING_CUSTOM_HOOK_TIMEOUT_MS = 30000;
-export declare const MINING_HOOK_STDOUT_MAX_BYTES = 262144;
-export declare const MINING_HOOK_STDERR_MAX_BYTES = 65536;
-export declare const MINING_HOOK_VALIDATION_TIMEOUT_MS = 10000;
-export declare const MINING_HOOK_TERMINATE_GRACE_MS = 2000;
-export declare const MINING_HOOK_FAILURE_THRESHOLD = 3;
-export declare const MINING_HOOK_COOLDOWN_MS = 300000;
+export declare const MINING_SENTENCE_SCHEMA_VERSION: 1;
+export declare const MINING_SENTENCE_MAX_CANDIDATE_SENTENCE_UTF8_BYTES = 512;
+export declare const MINING_SENTENCE_MAX_CANDIDATES_PER_ROOT_DOMAIN = 8;
+export declare const MINING_SENTENCE_MAX_CANDIDATES_TOTAL = 64;
+export declare const MINING_SENTENCE_TIMEOUT_MS = 30000;
 export declare const MINING_SHUTDOWN_GRACE_MS = 15000;
 export declare const MINING_SETTLEMENT_DUMMY_REWARD = 100n;

package/dist/wallet/mining/constants.js

@@ -8,17 +8,10 @@ export const MINING_PROVIDER_BACKOFF_BASE_MS = 30_000;
 export const MINING_PROVIDER_BACKOFF_MAX_MS = 900_000;
 export const MINING_LOOP_INTERVAL_MS = 2_000;
 export const MINING_BUILTIN_TIMEOUT_MS = 30_000;
-export const MINING_HOOK_SCHEMA_VERSION = 1;
-export const MINING_HOOK_MAX_CANDIDATE_SENTENCE_UTF8_BYTES = 512;
-export const MINING_HOOK_MAX_CANDIDATES_PER_ROOT_DOMAIN = 8;
-export const MINING_HOOK_MAX_CANDIDATES_TOTAL = 64;
-export const MINING_HOOK_TIMEOUT_MS = 30_000;
-export const MINING_CUSTOM_HOOK_TIMEOUT_MS = MINING_HOOK_TIMEOUT_MS;
-export const MINING_HOOK_STDOUT_MAX_BYTES = 262_144;
-export const MINING_HOOK_STDERR_MAX_BYTES = 65_536;
-export const MINING_HOOK_VALIDATION_TIMEOUT_MS = 10_000;
-export const MINING_HOOK_TERMINATE_GRACE_MS = 2_000;
-export const MINING_HOOK_FAILURE_THRESHOLD = 3;
-export const MINING_HOOK_COOLDOWN_MS = 300_000;
+export const MINING_SENTENCE_SCHEMA_VERSION = 1;
+export const MINING_SENTENCE_MAX_CANDIDATE_SENTENCE_UTF8_BYTES = 512;
+export const MINING_SENTENCE_MAX_CANDIDATES_PER_ROOT_DOMAIN = 8;
+export const MINING_SENTENCE_MAX_CANDIDATES_TOTAL = 64;
+export const MINING_SENTENCE_TIMEOUT_MS = 30_000;
 export const MINING_SHUTDOWN_GRACE_MS = 15_000;
 export const MINING_SETTLEMENT_DUMMY_REWARD = 100n;

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

@@ -1,4 +1,4 @@
-import { type WalletPrompter } from "../lifecycle.js";
+import type { WalletPrompter } from "../lifecycle.js";
 import { type WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import type { WalletBitcoindStatus, WalletIndexerStatus, WalletLocalStateStatus, WalletNodeStatus } from "../read/types.js";
@@ -10,7 +10,6 @@ export declare function inspectMiningControlPlane(options: {
     nodeStatus: WalletNodeStatus | null;
     nodeHealth: MiningRuntimeStatusV1["nodeHealth"];
     indexer: WalletIndexerStatus;
-    verify?: boolean;
     nowUnixMs?: number;
     paths?: WalletRuntimePaths;
 }): Promise<MiningControlPlaneView>;
@@ -24,17 +23,6 @@ export declare function refreshMiningRuntimeStatus(options: {
     nowUnixMs?: number;
     paths?: WalletRuntimePaths;
 }): Promise<MiningControlPlaneView>;
-export declare function enableMiningHooks(options: {
-    provider?: WalletSecretProvider;
-    prompter: WalletPrompter;
-    nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
-}): Promise<MiningControlPlaneView>;
-export declare function disableMiningHooks(options: {
-    provider?: WalletSecretProvider;
-    nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
-}): Promise<MiningControlPlaneView>;
 export declare function setupBuiltInMining(options: {
     provider?: WalletSecretProvider;
     prompter: WalletPrompter;

package/dist/wallet/mining/control.js

@@ -1,32 +1,12 @@
-import { randomBytes } from "node:crypto";
 import { acquireFileLock } from "../fs/lock.js";
-import { loadOrAutoUnlockWalletState } from "../lifecycle.js";
 import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
-import { saveWalletState } from "../state/storage.js";
 import { createDefaultWalletSecretProvider, createWalletSecretReference, } from "../state/provider.js";
-import { appendMiningEvent, getLastMiningEventTimestamp, loadMiningRuntimeStatus, readMiningEvents, saveMiningRuntimeStatus, followMiningEvents } from "./runtime-artifacts.js";
+import { loadWalletState } from "../state/storage.js";
+import { appendMiningEvent, getLastMiningEventTimestamp, loadMiningRuntimeStatus, readMiningEvents, saveMiningRuntimeStatus, followMiningEvents, } from "./runtime-artifacts.js";
 import { requestMiningGenerationPreemption } from "./coordination.js";
-import { ensureMiningHookTemplate, inspectMiningHookState, shouldEnterHookCooldown, validateCustomMiningHook, } from "./hooks.js";
 import { normalizeMiningPublishState, normalizeMiningStateRecord } from "./state.js";
 import { loadClientConfig, saveBuiltInMiningProviderConfig } from "./config.js";
-import { MINING_WORKER_API_VERSION } from "./constants.js";
-const WORKER_HEARTBEAT_STALE_MS = 15_000;
-function normalizeHookMode(mode) {
-    return mode === "custom" ? "custom" : "builtin";
-}
-function createDefaultHookState() {
-    return {
-        mode: "builtin",
-        validationState: "never",
-        lastValidationAtUnixMs: null,
-        lastValidationError: null,
-        validatedLaunchFingerprint: null,
-        validatedFullFingerprint: null,
-        fullTrustWarningAcknowledgedAtUnixMs: null,
-        consecutiveFailureCount: 0,
-        cooldownUntilUnixMs: null,
-    };
-}
+import { MINING_WORKER_API_VERSION, MINING_WORKER_HEARTBEAT_STALE_MS, } from "./constants.js";
 function createMiningEvent(kind, message, options = {}) {
     return {
         schemaVersion: 1,
@@ -81,19 +61,10 @@ async function isProcessAlive(pid) {
         return true;
     }
 }
-function mapProviderState(provider, hookMode, localState, nowUnixMs) {
+function mapProviderState(provider, localState) {
     const miningState = localState.state?.miningState === undefined
         ? null
         : normalizeMiningStateRecord(localState.state.miningState);
-    const hookState = localState.state?.hookClientState.mining ?? null;
-    const hookCooldownUntilUnixMs = hookState?.cooldownUntilUnixMs ?? null;
-    const hookCooldownActive = hookCooldownUntilUnixMs !== null
-        && hookCooldownUntilUnixMs > nowUnixMs;
-    if (hookMode === "custom") {
-        return hookState?.validationState === "failed" || hookCooldownActive
-            ? "hook-error"
-            : "n/a";
-    }
     if (miningState?.state === "paused" && miningState.pauseReason?.includes("rate-limit")) {
         return "rate-limited";
     }
@@ -106,9 +77,6 @@ function mapProviderState(provider, hookMode, localState, nowUnixMs) {
     if (provider.status === "ready") {
         return "ready";
     }
-    if (provider.status === "error") {
-        return "unavailable";
-    }
     return "unavailable";
 }
 function mapIndexerDaemonState(indexer) {
@@ -185,7 +153,7 @@ async function deriveBackgroundWorkerHealth(options) {
         return "stale-pid";
     }
     if (runtime.backgroundWorkerHeartbeatAtUnixMs === null
-        || (options.nowUnixMs - runtime.backgroundWorkerHeartbeatAtUnixMs) > WORKER_HEARTBEAT_STALE_MS) {
+        || (options.nowUnixMs - runtime.backgroundWorkerHeartbeatAtUnixMs) > MINING_WORKER_HEARTBEAT_STALE_MS) {
         return "stale-heartbeat";
     }
     return "healthy";
@@ -199,7 +167,7 @@ async function buildMiningRuntimeSnapshot(options) {
         localState: options.localState,
         nowUnixMs: options.nowUnixMs,
     });
-    const providerState = mapProviderState(options.provider, options.hookMode, options.localState, options.nowUnixMs);
+    const providerState = mapProviderState(options.provider, options.localState);
     const indexerDaemonState = mapIndexerDaemonState(options.indexer);
     const corePublishState = mapCorePublishState(options.nodeHealth, options.nodeStatus);
     const existing = options.existingRuntime;
@@ -243,7 +211,7 @@ async function buildMiningRuntimeSnapshot(options) {
         currentCanonicalBlend: state?.currentScore ?? existing?.currentCanonicalBlend ?? null,
         currentTxid: state?.currentTxid ?? existing?.currentTxid ?? null,
         currentWtxid: state?.currentWtxid ?? existing?.currentWtxid ?? null,
-        liveMiningFamilyInMempool: state?.liveMiningFamilyInMempool ?? existing?.liveMiningFamilyInMempool ?? null,
+        livePublishInMempool: state?.livePublishInMempool ?? existing?.livePublishInMempool ?? null,
         currentFeeRateSatVb: state?.currentFeeRateSatVb ?? existing?.currentFeeRateSatVb ?? null,
         currentAbsoluteFeeSats: state?.currentAbsoluteFeeSats ?? existing?.currentAbsoluteFeeSats ?? null,
         currentBlockFeeSpentSats: state?.currentBlockFeeSpentSats ?? existing?.currentBlockFeeSpentSats ?? "0",
@@ -258,7 +226,6 @@ async function buildMiningRuntimeSnapshot(options) {
         lastMempoolSequence: existing?.lastMempoolSequence ?? null,
         lastCompetitivenessGateAtUnixMs: existing?.lastCompetitivenessGateAtUnixMs ?? null,
         pauseReason: state?.pauseReason ?? options.existingRuntime?.pauseReason ?? null,
-        hookMode: options.hookMode,
         providerConfigured: options.provider.configured,
         providerKind: options.provider.provider,
         bitcoindHealth: options.bitcoind.health,
@@ -267,51 +234,35 @@ async function buildMiningRuntimeSnapshot(options) {
         nodeHealth: options.nodeHealth,
         indexerHealth: options.indexer.health,
         tipsAligned: options.tipsAligned,
-        lastValidationState: options.hookValidationState,
-        lastOperatorValidationState: options.hookOperatorValidationState,
-        lastValidationAtUnixMs: options.hookValidationAtUnixMs,
         lastEventAtUnixMs: options.lastEventAtUnixMs,
         lastError: existing?.lastError ?? options.provider.message ?? options.indexer.message ?? null,
-        note: options.hookMode === "custom" && options.hookCooldownActive
-            ? "Custom mining hook launch is paused during the post-failure cooldown window."
-            : options.hookMode === "custom" && options.hookOperatorValidationState !== "current"
-                ? "Custom mining hook is selected, but it must be revalidated before it can launch."
-                : state?.pauseReason === "zero-reward"
-                    ? "Mining is disabled because the target block reward is zero."
-                    : existing?.currentPhase === "resuming"
-                        ? "Mining discarded stale in-flight work after a large local runtime gap and is rechecking health."
-                        : existing?.currentPhase === "waiting-provider"
-                            ? "Mining is waiting for the sentence provider to recover."
-                            : existing?.currentPhase === "waiting-indexer"
-                                ? "Mining is waiting for Bitcoin Core and the indexer to align."
-                                : existing?.currentPhase === "waiting-bitcoin-network"
-                                    ? "Mining is waiting for the local Bitcoin node to become publishable."
-                                    : state?.state === "repair-required"
-                                        ? "Mining is blocked until the current mining family is reconciled or `cogcoin repair` completes."
-                                        : state?.state === "paused-stale" && state.liveMiningFamilyInMempool
-                                            ? "A previously broadcast mining family is still in mempool for an older tip context. Wait for confirmation or rerun mining to replace it."
-                                            : state?.state === "paused" && state.liveMiningFamilyInMempool
-                                                ? "Mining is paused, but the last mining transaction may still confirm from mempool without further fee bumps."
-                                                : state?.state === "paused"
-                                                    ? "Mining is paused by another wallet command or local policy."
-                                                    : options.provider.status === "missing"
-                                                        ? "Run `cogcoin mine setup` to configure the built-in mining provider."
-                                                        : options.indexer.health === "reorging"
-                                                            ? "Mining remains stopped while the indexer replays a reorg and refreshes the coherent snapshot."
-                                                            : options.indexer.health !== "synced" || options.nodeHealth !== "synced"
-                                                                ? "Mining remains stopped until Bitcoin Core and the indexer are both healthy and aligned."
-                                                                : null,
+        note: state?.pauseReason === "zero-reward"
+            ? "Mining is disabled because the target block reward is zero."
+            : existing?.currentPhase === "resuming"
+                ? "Mining discarded stale in-flight work after a large local runtime gap and is rechecking health."
+                : existing?.currentPhase === "waiting-provider"
+                    ? "Mining is waiting for the sentence provider to recover."
+                    : existing?.currentPhase === "waiting-indexer"
+                        ? "Mining is waiting for Bitcoin Core and the indexer to align."
+                        : existing?.currentPhase === "waiting-bitcoin-network"
+                            ? "Mining is waiting for the local Bitcoin node to become publishable."
+                            : state?.state === "repair-required"
+                                ? "Mining is blocked until the current mining publish is reconciled or `cogcoin repair` completes."
+                                : state?.state === "paused-stale" && state.livePublishInMempool
+                                    ? "A previously broadcast mining transaction is still in mempool for an older tip context. Wait for confirmation or rerun mining to replace it."
+                                    : state?.state === "paused" && state.livePublishInMempool
+                                        ? "Mining is paused, but the last mining transaction may still confirm from mempool without further fee bumps."
+                                        : state?.state === "paused"
+                                            ? "Mining is paused by another wallet command or local policy."
+                                            : options.provider.status === "missing"
+                                                ? "Run `cogcoin mine setup` to configure the built-in mining provider."
+                                                : options.indexer.health === "reorging"
+                                                    ? "Mining remains stopped while the indexer replays a reorg and refreshes the coherent snapshot."
+                                                    : options.indexer.health !== "synced" || options.nodeHealth !== "synced"
+                                                        ? "Mining remains stopped until Bitcoin Core and the indexer are both healthy and aligned."
+                                                        : null,
     };
 }
-async function persistWalletMiningHookState(options) {
-    await saveWalletState({
-        primaryPath: options.paths.walletStatePath,
-        backupPath: options.paths.walletStateBackupPath,
-    }, options.state, {
-        provider: options.provider,
-        secretReference: createWalletSecretReference(options.state.walletRootId),
-    });
-}
 async function loadMiningProviderConfig(options) {
     try {
         const config = await loadClientConfig({
@@ -338,14 +289,6 @@ export async function inspectMiningControlPlane(options) {
         paths,
         provider,
     });
-    const hookState = options.localState.state?.hookClientState.mining ?? null;
-    const hook = await inspectMiningHookState({
-        hookRootPath: paths.hooksMiningDir,
-        entrypointPath: paths.hooksMiningEntrypointPath,
-        packagePath: paths.hooksMiningPackageJsonPath,
-        localState: hookState,
-        verify: options.verify ?? false,
-    });
     const providerInspection = buildProviderInspection(providerConfig);
     const existingRuntime = await loadMiningRuntimeStatus(paths.miningStatusPath).catch(() => null);
     const lastEventAtUnixMs = await getLastMiningEventTimestamp(paths.miningEventsPath).catch(() => null);
@@ -357,11 +300,6 @@ export async function inspectMiningControlPlane(options) {
         localState: options.localState,
         bitcoind: options.bitcoind,
         nodeStatus: options.nodeStatus,
-        hookMode: normalizeHookMode(hook.mode === "unavailable" ? null : hook.mode),
-        hookValidationState: hook.validationState === "unavailable" ? null : hook.validationState,
-        hookOperatorValidationState: hook.operatorValidationState,
-        hookValidationAtUnixMs: hook.validatedAtUnixMs,
-        hookCooldownActive: hook.cooldownActive,
         provider: providerInspection,
         nodeHealth: options.nodeHealth,
         indexer: options.indexer,
@@ -371,7 +309,6 @@ export async function inspectMiningControlPlane(options) {
     });
     return {
         runtime,
-        hook,
         provider: providerInspection,
         lastEventAtUnixMs,
     };
@@ -382,246 +319,13 @@ export async function refreshMiningRuntimeStatus(options) {
     await saveMiningRuntimeStatus(paths.miningStatusPath, view.runtime);
     return view;
 }
-export async function enableMiningHooks(options) {
-    if (!options.prompter.isInteractive) {
-        throw new Error("mining_hooks_enable_requires_tty");
-    }
-    const provider = options.provider ?? createDefaultWalletSecretProvider();
-    const nowUnixMs = options.nowUnixMs ?? Date.now();
-    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
-    const controlLock = await acquireFileLock(paths.miningControlLockPath, {
-        purpose: "hooks-enable-mining",
-    });
-    try {
-        const preemption = await requestMiningGenerationPreemption({
-            paths,
-            reason: "hooks-enable-mining",
-        });
-        const unlocked = await loadOrAutoUnlockWalletState({
-            provider,
-            nowUnixMs,
-            paths,
-        });
-        try {
-            if (unlocked === null) {
-                throw new Error("wallet_locked");
-            }
-            const state = unlocked.state;
-            state.hookClientState.mining ??= createDefaultHookState();
-            if (state.hookClientState.mining.fullTrustWarningAcknowledgedAtUnixMs === null) {
-                options.prompter.writeLine("Enabling a custom mining hook gives local JavaScript code full access to your user account.");
-                const confirmation = await options.prompter.prompt("Type TRUST CUSTOM MINING HOOKS to continue: ");
-                if (confirmation.trim() !== "TRUST CUSTOM MINING HOOKS") {
-                    throw new Error("mining_hooks_enable_trust_acknowledgement_required");
-                }
-                state.hookClientState.mining.fullTrustWarningAcknowledgedAtUnixMs = nowUnixMs;
-            }
-            const createdTemplate = await ensureMiningHookTemplate({
-                hookRootPath: paths.hooksMiningDir,
-                entrypointPath: paths.hooksMiningEntrypointPath,
-                packagePath: paths.hooksMiningPackageJsonPath,
-            });
-            if (createdTemplate) {
-                await persistWalletMiningHookState({ state, provider, paths });
-                await appendMiningEvent(paths.miningEventsPath, createMiningEvent("custom-hook-template-created", "Created the default mining hook template. Edit it, then rerun `cogcoin hooks enable mining`.", { timestampUnixMs: nowUnixMs }));
-                await refreshMiningRuntimeStatus({
-                    provider,
-                    localState: {
-                        availability: "ready",
-                        walletRootId: state.walletRootId,
-                        state,
-                        source: unlocked.source,
-                        unlockUntilUnixMs: unlocked.session.unlockUntilUnixMs,
-                        hasPrimaryStateFile: true,
-                        hasBackupStateFile: true,
-                        hasUnlockSessionFile: true,
-                        message: null,
-                    },
-                    bitcoind: {
-                        health: "unavailable",
-                        status: null,
-                        message: "Managed bitcoind status unavailable during hook setup.",
-                    },
-                    nodeStatus: null,
-                    nodeHealth: "unavailable",
-                    indexer: {
-                        health: "unavailable",
-                        status: null,
-                        message: "Indexer status unavailable during hook setup.",
-                        snapshotTip: null,
-                        source: "none",
-                        daemonInstanceId: null,
-                        snapshotSeq: null,
-                        openedAtUnixMs: null,
-                    },
-                    nowUnixMs,
-                    paths,
-                });
-                throw new Error(`mining_hooks_enable_template_created:${paths.hooksMiningDir}`);
-            }
-            try {
-                const validation = await validateCustomMiningHook({
-                    hookRootPath: paths.hooksMiningDir,
-                    entrypointPath: paths.hooksMiningEntrypointPath,
-                    packagePath: paths.hooksMiningPackageJsonPath,
-                });
-                state.hookClientState.mining = {
-                    ...state.hookClientState.mining,
-                    mode: "custom",
-                    validationState: "current",
-                    lastValidationAtUnixMs: nowUnixMs,
-                    lastValidationError: null,
-                    validatedLaunchFingerprint: validation.launchFingerprint,
-                    validatedFullFingerprint: validation.fullFingerprint,
-                    consecutiveFailureCount: 0,
-                    cooldownUntilUnixMs: null,
-                };
-                await persistWalletMiningHookState({ state, provider, paths });
-                await appendMiningEvent(paths.miningEventsPath, createMiningEvent("custom-hook-enabled", "Custom mining hook enabled after validation.", { timestampUnixMs: nowUnixMs }));
-            }
-            catch (error) {
-                const validationError = error instanceof Error ? error.message : String(error);
-                const consecutiveFailureCount = (state.hookClientState.mining.consecutiveFailureCount ?? 0) + 1;
-                state.hookClientState.mining = {
-                    ...state.hookClientState.mining,
-                    validationState: "failed",
-                    lastValidationAtUnixMs: nowUnixMs,
-                    lastValidationError: validationError,
-                    validatedLaunchFingerprint: null,
-                    validatedFullFingerprint: null,
-                    consecutiveFailureCount,
-                    cooldownUntilUnixMs: shouldEnterHookCooldown({
-                        consecutiveFailureCount,
-                        nowUnixMs,
-                    }),
-                };
-                await persistWalletMiningHookState({ state, provider, paths });
-                await appendMiningEvent(paths.miningEventsPath, createMiningEvent("custom-hook-validation-failed", state.hookClientState.mining.lastValidationError ?? "Custom mining hook validation failed.", {
-                    level: "error",
-                    timestampUnixMs: nowUnixMs,
-                }));
-                throw new Error(`mining_hooks_enable_validation_failed:${validationError}`);
-            }
-            return refreshMiningRuntimeStatus({
-                provider,
-                localState: {
-                    availability: "ready",
-                    walletRootId: state.walletRootId,
-                    state,
-                    source: unlocked.source,
-                    unlockUntilUnixMs: unlocked.session.unlockUntilUnixMs,
-                    hasPrimaryStateFile: true,
-                    hasBackupStateFile: true,
-                    hasUnlockSessionFile: true,
-                    message: null,
-                },
-                bitcoind: {
-                    health: "unavailable",
-                    status: null,
-                    message: "Managed bitcoind status unavailable during hook setup.",
-                },
-                nodeStatus: null,
-                nodeHealth: "unavailable",
-                indexer: {
-                    health: "unavailable",
-                    status: null,
-                    message: "Indexer status unavailable during hook setup.",
-                    snapshotTip: null,
-                    source: "none",
-                    daemonInstanceId: null,
-                    snapshotSeq: null,
-                    openedAtUnixMs: null,
-                },
-                nowUnixMs,
-                paths,
-            });
-        }
-        finally {
-            await preemption.release();
-        }
-    }
-    finally {
-        await controlLock.release();
-    }
-}
-export async function disableMiningHooks(options) {
-    const provider = options.provider ?? createDefaultWalletSecretProvider();
-    const nowUnixMs = options.nowUnixMs ?? Date.now();
-    const paths = options.paths ?? resolveWalletRuntimePathsForTesting();
-    const controlLock = await acquireFileLock(paths.miningControlLockPath, {
-        purpose: "hooks-disable-mining",
-    });
-    try {
-        const preemption = await requestMiningGenerationPreemption({
-            paths,
-            reason: "hooks-disable-mining",
-        });
-        const unlocked = await loadOrAutoUnlockWalletState({
-            provider,
-            nowUnixMs,
-            paths,
-        });
-        try {
-            if (unlocked === null) {
-                throw new Error("wallet_locked");
-            }
-            const state = unlocked.state;
-            state.hookClientState.mining = {
-                ...createDefaultHookState(),
-                mode: "builtin",
-                fullTrustWarningAcknowledgedAtUnixMs: state.hookClientState.mining?.fullTrustWarningAcknowledgedAtUnixMs ?? null,
-            };
-            await persistWalletMiningHookState({ state, provider, paths });
-            await appendMiningEvent(paths.miningEventsPath, createMiningEvent("custom-hook-disabled", "Custom mining hook disabled. Built-in mining mode is active again.", { timestampUnixMs: nowUnixMs }));
-            return refreshMiningRuntimeStatus({
-                provider,
-                localState: {
-                    availability: "ready",
-                    walletRootId: state.walletRootId,
-                    state,
-                    source: unlocked.source,
-                    unlockUntilUnixMs: unlocked.session.unlockUntilUnixMs,
-                    hasPrimaryStateFile: true,
-                    hasBackupStateFile: true,
-                    hasUnlockSessionFile: true,
-                    message: null,
-                },
-                bitcoind: {
-                    health: "unavailable",
-                    status: null,
-                    message: "Managed bitcoind status unavailable during hook setup.",
-                },
-                nodeStatus: null,
-                nodeHealth: "unavailable",
-                indexer: {
-                    health: "unavailable",
-                    status: null,
-                    message: "Indexer status unavailable during hook setup.",
-                    snapshotTip: null,
-                    source: "none",
-                    daemonInstanceId: null,
-                    snapshotSeq: null,
-                    openedAtUnixMs: null,
-                },
-                nowUnixMs,
-                paths,
-            });
-        }
-        finally {
-            await preemption.release();
-        }
-    }
-    finally {
-        await controlLock.release();
-    }
-}
 function normalizeProviderChoice(raw) {
     const value = raw.trim().toLowerCase();
     return value === "openai" || value === "anthropic" ? value : null;
 }
 function writeBuiltInMiningProviderDisclosure(prompter) {
     prompter.writeLine("Built-in mining provider disclosure:");
-    prompter.writeLine("The built-in mining hook will send the following to the selected provider:");
+    prompter.writeLine("The built-in mining provider will send the following to the selected provider:");
     prompter.writeLine("- eligible anchored root domain names");
     prompter.writeLine("- the required five words for each root domain");
     prompter.writeLine("- target block height");
@@ -664,16 +368,13 @@ export async function setupBuiltInMining(options) {
             paths,
             reason: "mine-setup",
         });
-        const unlocked = await loadOrAutoUnlockWalletState({
-            provider,
-            nowUnixMs,
-            paths,
-        });
         try {
-            if (unlocked === null) {
-                throw new Error("wallet_locked");
-            }
-            const state = unlocked.state;
+            const loaded = await loadWalletState({
+                primaryPath: paths.walletStatePath,
+                backupPath: paths.walletStateBackupPath,
+            }, {
+                provider,
+            });
             await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-started", "Started built-in mining provider setup.", { timestampUnixMs: nowUnixMs }));
             try {
                 const config = await promptForMiningProviderConfig(options.prompter);
@@ -681,26 +382,21 @@ export async function setupBuiltInMining(options) {
                 await saveBuiltInMiningProviderConfig({
                     path: paths.clientConfigPath,
                     provider,
-                    secretReference: createWalletSecretReference(state.walletRootId),
+                    secretReference: createWalletSecretReference(loaded.state.walletRootId),
                     config,
                 });
-                state.hookClientState.mining ??= createDefaultHookState();
-                if (state.hookClientState.mining.mode === "disabled") {
-                    state.hookClientState.mining.mode = "builtin";
-                }
-                await persistWalletMiningHookState({ state, provider, paths });
                 await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-completed", `Configured the built-in ${config.provider} mining provider.`, { timestampUnixMs: nowUnixMs }));
                 return refreshMiningRuntimeStatus({
                     provider,
                     localState: {
                         availability: "ready",
-                        walletRootId: state.walletRootId,
-                        state,
-                        source: unlocked.source,
-                        unlockUntilUnixMs: unlocked.session.unlockUntilUnixMs,
+                        clientPasswordReadiness: "ready",
+                        unlockRequired: false,
+                        walletRootId: loaded.state.walletRootId,
+                        state: loaded.state,
+                        source: loaded.source,
                         hasPrimaryStateFile: true,
                         hasBackupStateFile: true,
-                        hasUnlockSessionFile: true,
                         message: null,
                     },
                     bitcoind: {

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

@@ -1,8 +1,7 @@
 export { isMiningGenerationAbortRequested, markMiningGenerationActive, markMiningGenerationInactive, readMiningGenerationActivity, readMiningPreemptionRequest, requestMiningGenerationPreemption, } from "./coordination.js";
-export { disableMiningHooks, enableMiningHooks, followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
+export { followMiningLog, inspectMiningControlPlane, readMiningLog, refreshMiningRuntimeStatus, setupBuiltInMining, } from "./control.js";
 export { runBackgroundMiningWorker, runForegroundMining, startBackgroundMining, stopBackgroundMining, type MiningStartResult, } from "./runner.js";
 export { appendMiningEvent, loadMiningRuntimeStatus, readMiningEvents, resolveRotatedMiningEventsPath, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";
-export { ensureMiningHookTemplate, inspectMiningHookState, runGenerateSentencesHookRequest, validateCustomMiningHook, } from "./hooks.js";
-export type { GenerateSentencesHookCandidateV1, GenerateSentencesHookRequestV1, GenerateSentencesHookResponseV1, MiningHookOperatorValidationState, } from "./hook-protocol.js";
+export type { MiningSentenceCandidateV1, MiningSentenceGenerationRequestV1, MiningSentenceGenerationResponseV1, } from "./sentence-protocol.js";
 export { loadClientConfig, saveBuiltInMiningProviderConfig, saveClientConfig, } from "./config.js";
-export type { ClientConfigV1, MiningControlPlaneView, MiningEventRecord, MiningHookInspection, MiningProviderConfigRecord, MiningProviderInspection, MiningRuntimeStatusV1, MiningServiceHealth, } from "./types.js";
+export type { ClientConfigV1, MiningControlPlaneView, MiningEventRecord, MiningProviderConfigRecord, MiningProviderInspection, MiningRuntimeStatusV1, MiningServiceHealth, } from "./types.js";