@cogcoin/client 1.0.1 → 1.0.2

package/dist/cli/update-service.js

@@ -0,0 +1,218 @@
+import { readFile } from "node:fs/promises";
+import { writeJsonFileAtomic } from "../wallet/fs/atomic.js";
+export const UPDATE_CHECK_CACHE_SCHEMA_VERSION = 1;
+export const UPDATE_CHECK_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const PASSIVE_UPDATE_CHECK_TIMEOUT_MS = 500;
+export const EXPLICIT_UPDATE_CHECK_TIMEOUT_MS = 5_000;
+export const UPDATE_CHECK_URL = "https://registry.npmjs.org/@cogcoin/client/latest";
+export const CLI_INSTALL_COMMAND = "npm install -g @cogcoin/client";
+export function createEmptyUpdateCheckCache() {
+    return {
+        schemaVersion: UPDATE_CHECK_CACHE_SCHEMA_VERSION,
+        lastCheckedAtUnixMs: 0,
+        latestVersion: null,
+        lastNotifiedCurrentVersion: null,
+        lastNotifiedLatestVersion: null,
+        lastNotifiedAtUnixMs: null,
+    };
+}
+export function parseSemver(version) {
+    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(version.trim());
+    if (match === null) {
+        return null;
+    }
+    const prerelease = match[4] === undefined
+        ? []
+        : match[4].split(".").map((raw) => ({
+            raw,
+            numeric: /^(0|[1-9]\d*)$/.test(raw),
+            numericValue: /^(0|[1-9]\d*)$/.test(raw) ? Number(raw) : null,
+        }));
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease,
+    };
+}
+export function compareSemver(left, right) {
+    const leftParsed = parseSemver(left);
+    const rightParsed = parseSemver(right);
+    if (leftParsed === null || rightParsed === null) {
+        return null;
+    }
+    if (leftParsed.major !== rightParsed.major) {
+        return leftParsed.major > rightParsed.major ? 1 : -1;
+    }
+    if (leftParsed.minor !== rightParsed.minor) {
+        return leftParsed.minor > rightParsed.minor ? 1 : -1;
+    }
+    if (leftParsed.patch !== rightParsed.patch) {
+        return leftParsed.patch > rightParsed.patch ? 1 : -1;
+    }
+    if (leftParsed.prerelease.length === 0 && rightParsed.prerelease.length === 0) {
+        return 0;
+    }
+    if (leftParsed.prerelease.length === 0) {
+        return 1;
+    }
+    if (rightParsed.prerelease.length === 0) {
+        return -1;
+    }
+    const maxLength = Math.max(leftParsed.prerelease.length, rightParsed.prerelease.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftIdentifier = leftParsed.prerelease[index];
+        const rightIdentifier = rightParsed.prerelease[index];
+        if (leftIdentifier === undefined) {
+            return -1;
+        }
+        if (rightIdentifier === undefined) {
+            return 1;
+        }
+        if (leftIdentifier.numeric && rightIdentifier.numeric) {
+            if (leftIdentifier.numericValue !== rightIdentifier.numericValue) {
+                return leftIdentifier.numericValue > rightIdentifier.numericValue ? 1 : -1;
+            }
+            continue;
+        }
+        if (leftIdentifier.numeric !== rightIdentifier.numeric) {
+            return leftIdentifier.numeric ? -1 : 1;
+        }
+        if (leftIdentifier.raw !== rightIdentifier.raw) {
+            return leftIdentifier.raw > rightIdentifier.raw ? 1 : -1;
+        }
+    }
+    return 0;
+}
+export function isUpdateCheckDisabled(env) {
+    const raw = env.COGCOIN_DISABLE_UPDATE_CHECK;
+    if (raw === undefined) {
+        return false;
+    }
+    const normalized = raw.trim().toLowerCase();
+    return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+function normalizeUpdateCheckCache(parsed) {
+    if (typeof parsed !== "object" || parsed === null) {
+        return null;
+    }
+    const candidate = parsed;
+    if (candidate.schemaVersion !== UPDATE_CHECK_CACHE_SCHEMA_VERSION) {
+        return null;
+    }
+    return {
+        schemaVersion: UPDATE_CHECK_CACHE_SCHEMA_VERSION,
+        lastCheckedAtUnixMs: typeof candidate.lastCheckedAtUnixMs === "number" ? candidate.lastCheckedAtUnixMs : 0,
+        latestVersion: typeof candidate.latestVersion === "string" ? candidate.latestVersion : null,
+        lastNotifiedCurrentVersion: typeof candidate.lastNotifiedCurrentVersion === "string"
+            ? candidate.lastNotifiedCurrentVersion
+            : null,
+        lastNotifiedLatestVersion: typeof candidate.lastNotifiedLatestVersion === "string"
+            ? candidate.lastNotifiedLatestVersion
+            : null,
+        lastNotifiedAtUnixMs: typeof candidate.lastNotifiedAtUnixMs === "number"
+            ? candidate.lastNotifiedAtUnixMs
+            : null,
+        lastCheckErrorKind: typeof candidate.lastCheckErrorKind === "string"
+            ? candidate.lastCheckErrorKind
+            : undefined,
+    };
+}
+export async function loadUpdateCheckCache(cachePath) {
+    try {
+        const raw = await readFile(cachePath, "utf8");
+        return normalizeUpdateCheckCache(JSON.parse(raw));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return null;
+        }
+        return null;
+    }
+}
+export function shouldRefreshUpdateCheck(cache, now) {
+    return now - cache.lastCheckedAtUnixMs >= UPDATE_CHECK_MAX_AGE_MS;
+}
+export function applyUpdateCheckResult(cache, result, now) {
+    return {
+        ...cache,
+        lastCheckedAtUnixMs: now,
+        latestVersion: result.kind === "success" ? result.latestVersion : cache.latestVersion,
+        lastCheckErrorKind: result.kind === "success" ? undefined : result.errorKind,
+    };
+}
+export function recordUpdateNotification(cache, currentVersion, latestVersion, now) {
+    return {
+        ...cache,
+        lastNotifiedCurrentVersion: currentVersion,
+        lastNotifiedLatestVersion: latestVersion,
+        lastNotifiedAtUnixMs: now,
+    };
+}
+export async function fetchLatestPublishedVersion(fetchImpl, options = {}) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => {
+        controller.abort();
+    }, options.timeoutMs ?? PASSIVE_UPDATE_CHECK_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(UPDATE_CHECK_URL, {
+            headers: {
+                accept: "application/json",
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return {
+                kind: "failure",
+                errorKind: `http_${response.status}`,
+            };
+        }
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            return {
+                kind: "failure",
+                errorKind: "invalid_json",
+            };
+        }
+        const latestVersion = typeof payload.version === "string"
+            ? payload.version
+            : null;
+        if (latestVersion === null) {
+            return {
+                kind: "failure",
+                errorKind: "invalid_payload",
+            };
+        }
+        if (parseSemver(latestVersion) === null) {
+            return {
+                kind: "failure",
+                errorKind: "invalid_semver",
+            };
+        }
+        return {
+            kind: "success",
+            latestVersion,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            return {
+                kind: "failure",
+                errorKind: "timeout",
+            };
+        }
+        return {
+            kind: "failure",
+            errorKind: "network",
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function persistUpdateCheckCache(cachePath, cache) {
+    await writeJsonFileAtomic(cachePath, cache);
+}

package/dist/client/initialization.js

@@ -22,6 +22,9 @@ export async function initializeState(store, genesisParameters) {
         if (tip !== null) {
             throw new Error("client_store_tip_without_snapshot");
         }
+        // Repair orphaned rewind rows from previously interrupted writers so the
+        // next replay pass does not collide on a stale future height.
+        await store.deleteBlockRecordsAbove(-1);
         return {
             state: createInitialState(genesisParameters),
             tip: null,
@@ -36,6 +39,7 @@ export async function initializeState(store, genesisParameters) {
         };
     }
     if (tip === null) {
+        await store.deleteBlockRecordsAbove(snapshot.height);
         return {
             state,
             tip: {
@@ -49,5 +53,6 @@ export async function initializeState(store, genesisParameters) {
     if (tip.height !== snapshot.height || tip.blockHashHex !== snapshot.blockHashHex) {
         throw new Error("client_store_snapshot_tip_mismatch");
     }
+    await store.deleteBlockRecordsAbove(tip.height);
     return { state, tip };
 }

package/dist/wallet/lifecycle.d.ts

@@ -10,6 +10,16 @@ export interface WalletPrompter {
     writeLine(message: string): void;
     prompt(message: string): Promise<string>;
     promptHidden?(message: string): Promise<string>;
+    selectOption?(options: {
+        message: string;
+        options: Array<{
+            label: string;
+            description?: string | null;
+            value: string;
+        }>;
+        initialValue?: string | null;
+        footer?: string | null;
+    }): Promise<string>;
     clearSensitiveDisplay?(scope: "mnemonic-reveal" | "restore-mnemonic-entry"): void | Promise<void>;
 }
 export interface WalletInitializationResult {

package/dist/wallet/lifecycle.js

@@ -174,6 +174,7 @@ async function normalizeLoadedWalletStateIfNeeded(options) {
             dataDir: options.dataDir,
             chain: "main",
             startHeight: 0,
+            serviceLifetime: "ephemeral",
             walletRootId: state.walletRootId,
         });
         try {
@@ -270,6 +271,7 @@ async function recreateManagedCoreWalletReplica(state, provider, paths, dataDir,
         dataDir,
         chain: "main",
         startHeight: 0,
+        serviceLifetime: "ephemeral",
         walletRootId: state.walletRootId,
         managedWalletPassphrase: state.managedCoreWallet.internalPassphrase,
     });
@@ -802,6 +804,7 @@ async function importDescriptorIntoManagedCoreWallet(state, provider, paths, dat
         dataDir,
         chain: "main",
         startHeight: 0,
+        serviceLifetime: "ephemeral",
         walletRootId: state.walletRootId,
         managedWalletPassphrase: state.managedCoreWallet.internalPassphrase,
     });
@@ -887,6 +890,7 @@ export async function verifyManagedCoreWalletReplica(state, dataDir, dependencie
             dataDir,
             chain: "main",
             startHeight: 0,
+            serviceLifetime: "ephemeral",
             walletRootId: state.walletRootId,
         });
         const rpc = (dependencies.rpcFactory ?? createRpcClient)(node.rpc);
@@ -1256,6 +1260,7 @@ export async function deleteImportedWalletSeed(options) {
                 dataDir: options.dataDir,
                 chain: "main",
                 startHeight: 0,
+                serviceLifetime: "ephemeral",
             });
             const rpc = (options.rpcFactory ?? createRpcClient)(node.rpc);
             const walletName = sanitizeWalletName(seedRecord.walletRootId);
@@ -1418,6 +1423,7 @@ export async function repairWallet(options) {
             dataDir: options.dataDir,
             chain: "main",
             startHeight: 0,
+            serviceLifetime: "ephemeral",
             walletRootId: repairedState.walletRootId,
         });
         const bitcoindRpc = (options.rpcFactory ?? createRpcClient)(bitcoindHandle.rpc);

package/dist/wallet/mining/config.js

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { writeJsonFileAtomic } from "../fs/atomic.js";
 import { decryptJsonWithSecretProvider, encryptJsonWithSecretProvider } from "../state/crypto.js";
+import { normalizeMiningProviderConfigRecord } from "./provider-model.js";
 function createEmptyClientConfig() {
     return {
         schemaVersion: 1,
@@ -9,10 +10,19 @@ function createEmptyClientConfig() {
         },
     };
 }
+function normalizeClientConfig(config) {
+    return {
+        ...config,
+        mining: {
+            ...config.mining,
+            builtIn: config.mining.builtIn === null ? null : normalizeMiningProviderConfigRecord(config.mining.builtIn),
+        },
+    };
+}
 export async function loadClientConfig(options) {
     try {
         const raw = await readFile(options.path, "utf8");
-        return await decryptJsonWithSecretProvider(JSON.parse(raw), options.provider);
+        return normalizeClientConfig(await decryptJsonWithSecretProvider(JSON.parse(raw), options.provider));
     }
     catch (error) {
         if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -22,7 +32,7 @@ export async function loadClientConfig(options) {
     }
 }
 export async function saveClientConfig(options) {
-    const envelope = await encryptJsonWithSecretProvider(options.config, options.provider, options.secretReference, {
+    const envelope = await encryptJsonWithSecretProvider(normalizeClientConfig(options.config), options.provider, options.secretReference, {
         format: "cogcoin-client-config",
     });
     await writeJsonFileAtomic(options.path, envelope, { mode: 0o600 });
@@ -33,7 +43,7 @@ export async function saveBuiltInMiningProviderConfig(options) {
         provider: options.provider,
     }).catch(() => null);
     const nextConfig = existing ?? createEmptyClientConfig();
-    nextConfig.mining.builtIn = options.config;
+    nextConfig.mining.builtIn = normalizeMiningProviderConfigRecord(options.config);
     await saveClientConfig({
         path: options.path,
         provider: options.provider,

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

@@ -2,7 +2,7 @@ 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";
-import type { MiningControlPlaneView, MiningEventRecord, MiningRuntimeStatusV1 } from "./types.js";
+import type { MiningControlPlaneView, MiningEventRecord, MiningProviderConfigRecord, MiningRuntimeStatusV1 } from "./types.js";
 export declare function inspectMiningControlPlane(options: {
     provider?: WalletSecretProvider;
     localState: WalletLocalStateStatus;
@@ -23,6 +23,7 @@ export declare function refreshMiningRuntimeStatus(options: {
     nowUnixMs?: number;
     paths?: WalletRuntimePaths;
 }): Promise<MiningControlPlaneView>;
+export declare function promptForMiningProviderConfigForTesting(prompter: WalletPrompter, eligibleRootCount: number): Promise<MiningProviderConfigRecord>;
 export declare function setupBuiltInMining(options: {
     provider?: WalletSecretProvider;
     prompter: WalletPrompter;

package/dist/wallet/mining/control.js

@@ -2,11 +2,13 @@ import { acquireFileLock } from "../fs/lock.js";
 import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, createWalletSecretReference, } from "../state/provider.js";
 import { loadWalletState } from "../state/storage.js";
+import { isRootDomainName } from "../read/filter.js";
 import { appendMiningEvent, getLastMiningEventTimestamp, loadMiningRuntimeStatus, readMiningEvents, saveMiningRuntimeStatus, followMiningEvents, } from "./runtime-artifacts.js";
 import { requestMiningGenerationPreemption } from "./coordination.js";
 import { normalizeMiningPublishState, normalizeMiningStateRecord } from "./state.js";
 import { loadClientConfig, saveBuiltInMiningProviderConfig } from "./config.js";
 import { MINING_WORKER_API_VERSION, MINING_WORKER_HEARTBEAT_STALE_MS, } from "./constants.js";
+import { estimateBuiltInModelDailyCost, getBuiltInProviderModelCatalog, getRecommendedBuiltInProviderModel, MINING_MODEL_DAILY_COST_ESTIMATE_ASSUMPTION, resolveBuiltInProviderSelection, } from "./provider-model.js";
 function createMiningEvent(kind, message, options = {}) {
     return {
         schemaVersion: 1,
@@ -23,8 +25,14 @@ function buildProviderInspection(options) {
             provider: null,
             status: "error",
             message: options.error,
+            modelId: null,
+            effectiveModel: null,
             modelOverride: null,
+            modelSelectionSource: null,
+            usingDefaultModel: null,
             extraPromptConfigured: false,
+            estimatedDailyCostUsd: null,
+            estimatedDailyCostDisplay: null,
         };
     }
     if (options.config === null) {
@@ -33,19 +41,50 @@ function buildProviderInspection(options) {
             provider: null,
             status: "missing",
             message: "Built-in mining provider is not configured yet.",
+            modelId: null,
+            effectiveModel: null,
             modelOverride: null,
+            modelSelectionSource: null,
+            usingDefaultModel: null,
             extraPromptConfigured: false,
+            estimatedDailyCostUsd: null,
+            estimatedDailyCostDisplay: null,
         };
     }
+    const selection = resolveBuiltInProviderSelection(options.config);
+    const estimate = options.eligibleRootCount === null
+        ? null
+        : estimateBuiltInModelDailyCost(options.config.provider, selection.modelId, options.eligibleRootCount);
     return {
         configured: true,
         provider: options.config.provider,
         status: "ready",
         message: null,
+        modelId: selection.modelId,
+        effectiveModel: selection.effectiveModel,
         modelOverride: options.config.modelOverride,
+        modelSelectionSource: selection.modelSelectionSource,
+        usingDefaultModel: selection.usingDefaultModel,
         extraPromptConfigured: options.config.extraPrompt !== null && options.config.extraPrompt.length > 0,
+        estimatedDailyCostUsd: estimate?.estimatedDailyCostUsd ?? null,
+        estimatedDailyCostDisplay: estimate?.estimatedDailyCostDisplay ?? null,
     };
 }
+function countEligibleAnchoredRoots(localState) {
+    const state = localState.state;
+    if (state === null || state === undefined) {
+        return null;
+    }
+    let count = 0;
+    for (const domain of state.domains) {
+        if (isRootDomainName(domain.name)
+            && domain.canonicalChainStatus === "anchored"
+            && domain.currentOwnerScriptPubKeyHex === state.funding.scriptPubKeyHex) {
+            count += 1;
+        }
+    }
+    return count;
+}
 async function isProcessAlive(pid) {
     if (pid === null) {
         return false;
@@ -61,10 +100,13 @@ async function isProcessAlive(pid) {
         return true;
     }
 }
-function mapProviderState(provider, localState) {
+function mapProviderState(provider, localState, existingRuntime) {
     const miningState = localState.state?.miningState === undefined
         ? null
         : normalizeMiningStateRecord(localState.state.miningState);
+    if (existingRuntime?.currentPhase === "waiting-provider" && existingRuntime.providerState !== null) {
+        return existingRuntime.providerState;
+    }
     if (miningState?.state === "paused" && miningState.pauseReason?.includes("rate-limit")) {
         return "rate-limited";
     }
@@ -167,7 +209,7 @@ async function buildMiningRuntimeSnapshot(options) {
         localState: options.localState,
         nowUnixMs: options.nowUnixMs,
     });
-    const providerState = mapProviderState(options.provider, options.localState);
+    const providerState = mapProviderState(options.provider, options.localState, options.existingRuntime);
     const indexerDaemonState = mapIndexerDaemonState(options.indexer);
     const corePublishState = mapCorePublishState(options.nodeHealth, options.nodeStatus);
     const existing = options.existingRuntime;
@@ -289,7 +331,10 @@ export async function inspectMiningControlPlane(options) {
         paths,
         provider,
     });
-    const providerInspection = buildProviderInspection(providerConfig);
+    const providerInspection = buildProviderInspection({
+        ...providerConfig,
+        eligibleRootCount: countEligibleAnchoredRoots(options.localState),
+    });
     const existingRuntime = await loadMiningRuntimeStatus(paths.miningStatusPath).catch(() => null);
     const lastEventAtUnixMs = await getLastMiningEventTimestamp(paths.miningEventsPath).catch(() => null);
     const nodeBestHeight = options.nodeStatus?.nodeBestHeight ?? null;
@@ -323,6 +368,20 @@ function normalizeProviderChoice(raw) {
     const value = raw.trim().toLowerCase();
     return value === "openai" || value === "anthropic" ? value : null;
 }
+function describeModelSelectionSource(source) {
+    switch (source) {
+        case "catalog":
+            return "catalog";
+        case "custom":
+            return "custom";
+        case "legacy-default":
+            return "legacy-default";
+        case "legacy-custom":
+            return "legacy-custom";
+        default:
+            throw new Error(`unsupported_model_selection_source:${String(source)}`);
+    }
+}
 function writeBuiltInMiningProviderDisclosure(prompter) {
     prompter.writeLine("Built-in mining provider disclosure:");
     prompter.writeLine("The built-in mining provider will send the following to the selected provider:");
@@ -332,27 +391,83 @@ function writeBuiltInMiningProviderDisclosure(prompter) {
     prompter.writeLine("- referenced previous-block hash");
     prompter.writeLine("- optional extra prompt when configured");
 }
-async function promptForMiningProviderConfig(prompter) {
+async function promptForMiningProviderModelSelectionFallback(prompter, options) {
+    prompter.writeLine(options.message);
+    for (const [index, option] of options.options.entries()) {
+        const description = option.description == null || option.description.length === 0
+            ? ""
+            : ` - ${option.description}`;
+        prompter.writeLine(`${index + 1}. ${option.label}${description}`);
+    }
+    if (options.footer != null && options.footer.length > 0) {
+        prompter.writeLine(options.footer);
+    }
+    while (true) {
+        const answer = (await prompter.prompt(`Choice [1-${options.options.length}]: `)).trim();
+        if (/^(q|quit|esc|escape)$/i.test(answer)) {
+            throw new Error("mining_setup_canceled");
+        }
+        const choice = Number.parseInt(answer, 10);
+        if (Number.isInteger(choice) && choice >= 1 && choice <= options.options.length) {
+            return options.options[choice - 1].value;
+        }
+        prompter.writeLine(`Enter a number from 1 to ${options.options.length}, or q to cancel.`);
+    }
+}
+async function promptForMiningProviderConfig(prompter, eligibleRootCount) {
     writeBuiltInMiningProviderDisclosure(prompter);
     const providerInput = await prompter.prompt("Provider (openai/anthropic): ");
     const provider = normalizeProviderChoice(providerInput);
     if (provider === null) {
         throw new Error("mining_setup_invalid_provider");
     }
+    const selectorOptions = {
+        message: "Choose the mining model:",
+        options: [
+            ...getBuiltInProviderModelCatalog(provider).map((entry) => {
+                const estimate = estimateBuiltInModelDailyCost(provider, entry.modelId, eligibleRootCount);
+                return {
+                    label: entry.label,
+                    description: `${entry.modelId} - ${estimate?.estimatedDailyCostDisplay ?? "n/a"}`,
+                    value: entry.modelId,
+                };
+            }),
+            {
+                label: "Custom model ID...",
+                description: null,
+                value: "custom",
+            },
+        ],
+        initialValue: getRecommendedBuiltInProviderModel(provider),
+        footer: MINING_MODEL_DAILY_COST_ESTIMATE_ASSUMPTION,
+    };
+    const selectedModelId = prompter.selectOption == null
+        ? await promptForMiningProviderModelSelectionFallback(prompter, selectorOptions)
+        : await prompter.selectOption(selectorOptions);
+    const modelSelectionSource = selectedModelId === "custom" ? "custom" : "catalog";
+    const modelOverride = selectedModelId === "custom"
+        ? (await prompter.prompt("Custom model ID: ")).trim()
+        : selectedModelId;
+    if (modelOverride.length === 0) {
+        throw new Error("mining_setup_missing_model_id");
+    }
     const apiKey = (await prompter.prompt("API key: ")).trim();
     if (apiKey.length === 0) {
         throw new Error("mining_setup_missing_api_key");
     }
     const extraPrompt = (await prompter.prompt("Extra prompt (optional, blank for none): ")).trim();
-    const modelOverride = (await prompter.prompt("Model override (optional, blank for default): ")).trim();
     return {
         provider,
         apiKey,
         extraPrompt: extraPrompt.length === 0 ? null : extraPrompt,
-        modelOverride: modelOverride.length === 0 ? null : modelOverride,
+        modelOverride,
+        modelSelectionSource,
         updatedAtUnixMs: Date.now(),
     };
 }
+export async function promptForMiningProviderConfigForTesting(prompter, eligibleRootCount) {
+    return await promptForMiningProviderConfig(prompter, eligibleRootCount);
+}
 export async function setupBuiltInMining(options) {
     if (!options.prompter.isInteractive) {
         throw new Error("mine_setup_requires_tty");
@@ -375,9 +490,21 @@ export async function setupBuiltInMining(options) {
             }, {
                 provider,
             });
+            const localState = {
+                availability: "ready",
+                clientPasswordReadiness: "ready",
+                unlockRequired: false,
+                walletRootId: loaded.state.walletRootId,
+                state: loaded.state,
+                source: loaded.source,
+                hasPrimaryStateFile: true,
+                hasBackupStateFile: true,
+                message: null,
+            };
+            const eligibleRootCount = countEligibleAnchoredRoots(localState) ?? 0;
             await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-started", "Started built-in mining provider setup.", { timestampUnixMs: nowUnixMs }));
             try {
-                const config = await promptForMiningProviderConfig(options.prompter);
+                const config = await promptForMiningProviderConfig(options.prompter, eligibleRootCount);
                 config.updatedAtUnixMs = nowUnixMs;
                 await saveBuiltInMiningProviderConfig({
                     path: paths.clientConfigPath,
@@ -385,20 +512,10 @@ export async function setupBuiltInMining(options) {
                     secretReference: createWalletSecretReference(loaded.state.walletRootId),
                     config,
                 });
-                await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-completed", `Configured the built-in ${config.provider} mining provider.`, { timestampUnixMs: nowUnixMs }));
+                await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-completed", `Configured the built-in ${config.provider} mining provider with model ${config.modelOverride} (${describeModelSelectionSource(config.modelSelectionSource)}).`, { timestampUnixMs: nowUnixMs }));
                 return refreshMiningRuntimeStatus({
                     provider,
-                    localState: {
-                        availability: "ready",
-                        clientPasswordReadiness: "ready",
-                        unlockRequired: false,
-                        walletRootId: loaded.state.walletRootId,
-                        state: loaded.state,
-                        source: loaded.source,
-                        hasPrimaryStateFile: true,
-                        hasBackupStateFile: true,
-                        message: null,
-                    },
+                    localState,
                     bitcoind: {
                         health: "unavailable",
                         status: null,
@@ -421,6 +538,13 @@ export async function setupBuiltInMining(options) {
                 });
             }
             catch (error) {
+                if (error instanceof Error && error.message === "mining_setup_canceled") {
+                    await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-canceled", "Canceled built-in mining provider setup.", {
+                        level: "warn",
+                        timestampUnixMs: nowUnixMs,
+                    }));
+                    throw error;
+                }
                 await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-failed", error instanceof Error ? error.message : String(error), {
                     level: "error",
                     timestampUnixMs: nowUnixMs,

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

@@ -4,4 +4,4 @@ export { ensureBuiltInMiningSetupIfNeeded, runBackgroundMiningWorker, runForegro
 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";
-export type { ClientConfigV1, MiningControlPlaneView, MiningEventRecord, MiningProviderConfigRecord, MiningProviderInspection, MiningRuntimeStatusV1, MiningServiceHealth, } from "./types.js";
+export type { ClientConfigV1, MiningControlPlaneView, MiningEventRecord, MiningModelSelectionSource, MiningProviderConfigRecord, MiningProviderInspection, MiningRuntimeStatusV1, MiningServiceHealth, } from "./types.js";