@cogcoin/client 1.0.2 → 1.1.0

package/dist/wallet/mining/config.js

@@ -2,20 +2,66 @@ 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";
+const MINING_PROVIDER_KINDS = ["openai", "anthropic"];
+function normalizeDomainExtraPrompts(raw) {
+    if (raw === null || typeof raw !== "object") {
+        return {};
+    }
+    const normalized = new Map();
+    for (const [rawDomainName, rawPrompt] of Object.entries(raw)) {
+        if (typeof rawPrompt !== "string") {
+            continue;
+        }
+        const domainName = rawDomainName.trim().toLowerCase();
+        const prompt = rawPrompt.trim();
+        if (domainName.length === 0 || prompt.length === 0) {
+            continue;
+        }
+        normalized.set(domainName, prompt);
+    }
+    return Object.fromEntries([...normalized.entries()].sort(([left], [right]) => left.localeCompare(right)));
+}
 function createEmptyClientConfig() {
     return {
         schemaVersion: 1,
         mining: {
             builtIn: null,
+            domainExtraPrompts: {},
         },
     };
 }
+function normalizeBuiltInProviderConfigMap(raw) {
+    if (raw === null || typeof raw !== "object") {
+        return {};
+    }
+    const normalized = {};
+    const entries = raw;
+    for (const provider of MINING_PROVIDER_KINDS) {
+        const config = entries[provider];
+        if (config == null) {
+            continue;
+        }
+        normalized[provider] = normalizeMiningProviderConfigRecord({
+            ...config,
+            provider,
+        });
+    }
+    return normalized;
+}
 function normalizeClientConfig(config) {
+    const mining = config.mining ?? createEmptyClientConfig().mining;
+    const builtIn = mining.builtIn === null ? null : normalizeMiningProviderConfigRecord(mining.builtIn);
+    const builtInByProvider = normalizeBuiltInProviderConfigMap(mining.builtInByProvider);
+    if (builtIn !== null) {
+        builtInByProvider[builtIn.provider] = builtIn;
+    }
     return {
         ...config,
         mining: {
-            ...config.mining,
-            builtIn: config.mining.builtIn === null ? null : normalizeMiningProviderConfigRecord(config.mining.builtIn),
+            ...mining,
+            builtIn,
+            ...(Object.keys(builtInByProvider).length === 0 ? {} : { builtInByProvider }),
+            domainExtraPrompts: normalizeDomainExtraPrompts(mining.domainExtraPrompts),
         },
     };
 }
@@ -43,7 +89,12 @@ export async function saveBuiltInMiningProviderConfig(options) {
         provider: options.provider,
     }).catch(() => null);
     const nextConfig = existing ?? createEmptyClientConfig();
-    nextConfig.mining.builtIn = normalizeMiningProviderConfigRecord(options.config);
+    const normalizedConfig = normalizeMiningProviderConfigRecord(options.config);
+    nextConfig.mining.builtIn = normalizedConfig;
+    nextConfig.mining.builtInByProvider = {
+        ...(nextConfig.mining.builtInByProvider ?? {}),
+        [normalizedConfig.provider]: normalizedConfig,
+    };
     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, MiningProviderConfigRecord, MiningRuntimeStatusV1 } from "./types.js";
+import type { MiningControlPlaneView, MiningEventRecord, MiningProviderConfigByProvider, MiningProviderConfigRecord, MiningRuntimeStatusV1 } from "./types.js";
 export declare function inspectMiningControlPlane(options: {
     provider?: WalletSecretProvider;
     localState: WalletLocalStateStatus;
@@ -23,7 +23,10 @@ export declare function refreshMiningRuntimeStatus(options: {
     nowUnixMs?: number;
     paths?: WalletRuntimePaths;
 }): Promise<MiningControlPlaneView>;
-export declare function promptForMiningProviderConfigForTesting(prompter: WalletPrompter, eligibleRootCount: number): Promise<MiningProviderConfigRecord>;
+export declare function promptForMiningProviderConfigForTesting(prompter: WalletPrompter, eligibleRootCount: number, options?: {
+    currentConfig?: MiningProviderConfigRecord | null;
+    rememberedConfigs?: MiningProviderConfigByProvider;
+}): Promise<MiningProviderConfigRecord>;
 export declare function setupBuiltInMining(options: {
     provider?: WalletSecretProvider;
     prompter: WalletPrompter;

package/dist/wallet/mining/control.js

@@ -9,6 +9,7 @@ import { normalizeMiningPublishState, normalizeMiningStateRecord } from "./state
 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";
+const KEEP_CURRENT_MODEL_SELECTION = "__keep_current__";
 function createMiningEvent(kind, message, options = {}) {
     return {
         schemaVersion: 1,
@@ -414,59 +415,170 @@ async function promptForMiningProviderModelSelectionFallback(prompter, options)
         prompter.writeLine(`Enter a number from 1 to ${options.options.length}, or q to cancel.`);
     }
 }
-async function promptForMiningProviderConfig(prompter, eligibleRootCount) {
+function formatMiningProviderDisplayName(provider) {
+    return provider === "openai" ? "OpenAI" : "Anthropic";
+}
+async function promptMiningSetupYesNo(prompter, message, defaultAnswer) {
+    const prompt = `${message}${defaultAnswer ? " [Y/n]: " : " [y/N]: "}`;
+    while (true) {
+        const answer = (await prompter.prompt(prompt)).trim().toLowerCase();
+        if (answer.length === 0) {
+            return defaultAnswer;
+        }
+        if (answer === "y" || answer === "yes") {
+            return true;
+        }
+        if (answer === "n" || answer === "no") {
+            return false;
+        }
+        if (answer === "q" || answer === "quit" || answer === "esc" || answer === "escape") {
+            throw new Error("mining_setup_canceled");
+        }
+        prompter.writeLine("Enter y or n, or q to cancel.");
+    }
+}
+function buildMiningProviderModelSelectorOptions(provider, eligibleRootCount, currentConfig) {
+    const catalogOptions = 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,
+        };
+    });
+    const selection = currentConfig === null ? null : resolveBuiltInProviderSelection(currentConfig);
+    const options = [...catalogOptions];
+    let initialValue = getRecommendedBuiltInProviderModel(provider);
+    if (selection !== null) {
+        if (selection.modelSelectionSource === "custom" || selection.modelSelectionSource === "legacy-custom") {
+            initialValue = "custom";
+        }
+        else if (catalogOptions.some((entry) => entry.value === selection.modelId)) {
+            initialValue = selection.modelId;
+        }
+        else {
+            options.push({
+                label: "Current configured model",
+                description: `${selection.modelId} - current saved setting`,
+                value: KEEP_CURRENT_MODEL_SELECTION,
+            });
+            initialValue = KEEP_CURRENT_MODEL_SELECTION;
+        }
+    }
+    options.push({
+        label: "Custom model ID...",
+        description: "",
+        value: "custom",
+    });
+    return {
+        initialValue,
+        options,
+    };
+}
+async function promptForMiningProviderConfig(prompter, eligibleRootCount, options = {}) {
     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 currentConfig = options.currentConfig ?? null;
+    const rememberedConfigs = options.rememberedConfigs ?? {};
+    let provider;
+    let rememberedConfig = currentConfig;
+    let reuseSavedApiKey = false;
+    if (currentConfig !== null) {
+        const useDifferentProviderOrApiKey = await promptMiningSetupYesNo(prompter, "Use a different provider or API key?", false);
+        if (!useDifferentProviderOrApiKey) {
+            provider = currentConfig.provider;
+            reuseSavedApiKey = true;
+        }
+        else {
+            const providerInput = await prompter.prompt("Provider (openai/anthropic): ");
+            const selectedProvider = normalizeProviderChoice(providerInput);
+            if (selectedProvider === null) {
+                throw new Error("mining_setup_invalid_provider");
+            }
+            provider = selectedProvider;
+            rememberedConfig = rememberedConfigs[provider] ?? null;
+            if (rememberedConfig !== null) {
+                reuseSavedApiKey = await promptMiningSetupYesNo(prompter, `Use saved ${formatMiningProviderDisplayName(provider)} API key?`, true);
+            }
+        }
+    }
+    else {
+        const providerInput = await prompter.prompt("Provider (openai/anthropic): ");
+        const selectedProvider = normalizeProviderChoice(providerInput);
+        if (selectedProvider === null) {
+            throw new Error("mining_setup_invalid_provider");
+        }
+        provider = selectedProvider;
+        rememberedConfig = rememberedConfigs[provider] ?? null;
+        if (rememberedConfig !== null) {
+            reuseSavedApiKey = await promptMiningSetupYesNo(prompter, `Use saved ${formatMiningProviderDisplayName(provider)} API key?`, true);
+        }
     }
+    const selectorModelOptions = buildMiningProviderModelSelectorOptions(provider, eligibleRootCount, rememberedConfig);
     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),
+        options: selectorModelOptions.options,
+        initialValue: selectorModelOptions.initialValue,
         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();
+    let modelSelectionSource;
+    let modelOverride;
+    if (selectedModelId === KEEP_CURRENT_MODEL_SELECTION) {
+        if (rememberedConfig === null) {
+            throw new Error("mining_setup_missing_model_id");
+        }
+        modelSelectionSource = rememberedConfig.modelSelectionSource;
+        modelOverride = rememberedConfig.modelOverride;
+    }
+    else if (selectedModelId === "custom") {
+        const currentCustomModel = rememberedConfig !== null
+            && (rememberedConfig.modelSelectionSource === "custom" || rememberedConfig.modelSelectionSource === "legacy-custom")
+            ? rememberedConfig.modelOverride
+            : null;
+        const customModelId = (await prompter.prompt(currentCustomModel === null
+            ? "Custom model ID: "
+            : `Custom model ID (blank to keep current: ${currentCustomModel}): `)).trim();
+        if (customModelId.length === 0) {
+            if (currentCustomModel === null) {
+                throw new Error("mining_setup_missing_model_id");
+            }
+            modelSelectionSource = rememberedConfig?.modelSelectionSource ?? "custom";
+            modelOverride = currentCustomModel;
+        }
+        else {
+            modelSelectionSource = "custom";
+            modelOverride = customModelId;
+        }
+    }
+    else {
+        modelSelectionSource = "catalog";
+        modelOverride = selectedModelId;
+    }
+    const apiKey = reuseSavedApiKey && rememberedConfig !== null
+        ? rememberedConfig.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 extraPromptInput = (await prompter.prompt(rememberedConfig === null
+        ? "Extra prompt (optional, blank for none): "
+        : `Extra prompt (optional, blank to keep current: ${rememberedConfig.extraPrompt ?? "none"}): `)).trim();
+    const extraPrompt = extraPromptInput.length === 0
+        ? rememberedConfig?.extraPrompt ?? null
+        : extraPromptInput;
     return {
         provider,
         apiKey,
-        extraPrompt: extraPrompt.length === 0 ? null : extraPrompt,
+        extraPrompt: extraPrompt === null || extraPrompt.length === 0 ? null : extraPrompt,
         modelOverride,
         modelSelectionSource,
         updatedAtUnixMs: Date.now(),
     };
 }
-export async function promptForMiningProviderConfigForTesting(prompter, eligibleRootCount) {
-    return await promptForMiningProviderConfig(prompter, eligibleRootCount);
+export async function promptForMiningProviderConfigForTesting(prompter, eligibleRootCount, options = {}) {
+    return await promptForMiningProviderConfig(prompter, eligibleRootCount, options);
 }
 export async function setupBuiltInMining(options) {
     if (!options.prompter.isInteractive) {
@@ -502,9 +614,16 @@ export async function setupBuiltInMining(options) {
                 message: null,
             };
             const eligibleRootCount = countEligibleAnchoredRoots(localState) ?? 0;
+            const clientConfig = await loadClientConfig({
+                path: paths.clientConfigPath,
+                provider,
+            }).catch(() => null);
             await appendMiningEvent(paths.miningEventsPath, createMiningEvent("mine-setup-started", "Started built-in mining provider setup.", { timestampUnixMs: nowUnixMs }));
             try {
-                const config = await promptForMiningProviderConfig(options.prompter, eligibleRootCount);
+                const config = await promptForMiningProviderConfig(options.prompter, eligibleRootCount, {
+                    currentConfig: clientConfig?.mining.builtIn ?? null,
+                    rememberedConfigs: clientConfig?.mining.builtInByProvider ?? {},
+                });
                 config.updatedAtUnixMs = nowUnixMs;
                 await saveBuiltInMiningProviderConfig({
                     path: paths.clientConfigPath,

package/dist/wallet/mining/domain-prompts.d.ts

@@ -0,0 +1,17 @@
+import type { WalletReadContext } from "../read/index.js";
+import { type WalletSecretProvider } from "../state/provider.js";
+import type { WalletRuntimePaths } from "../runtime.js";
+import type { MiningDomainPromptListResult, MiningDomainPromptMutationResult } from "./types.js";
+export declare function canonicalizeMiningDomainPromptName(domainName: string): string;
+export declare function inspectMiningDomainPromptState(options: {
+    paths: WalletRuntimePaths;
+    provider: WalletSecretProvider;
+    readContext: WalletReadContext;
+}): Promise<MiningDomainPromptListResult>;
+export declare function updateMiningDomainPrompt(options: {
+    paths: WalletRuntimePaths;
+    provider: WalletSecretProvider;
+    readContext: WalletReadContext;
+    domainName: string;
+    prompt: string | null;
+}): Promise<MiningDomainPromptMutationResult>;

package/dist/wallet/mining/domain-prompts.js

@@ -0,0 +1,130 @@
+import { findWalletDomain, isMineableWalletDomain } from "../read/index.js";
+import { createWalletSecretReference } from "../state/provider.js";
+import { loadClientConfig, saveClientConfig } from "./config.js";
+function createEmptyClientConfig() {
+    return {
+        schemaVersion: 1,
+        mining: {
+            builtIn: null,
+            domainExtraPrompts: {},
+        },
+    };
+}
+export function canonicalizeMiningDomainPromptName(domainName) {
+    return domainName.trim().toLowerCase();
+}
+function fallbackPromptConfigured(config) {
+    const extraPrompt = config?.mining.builtIn?.extraPrompt ?? null;
+    return extraPrompt !== null && extraPrompt.length > 0;
+}
+function listMineableDomains(readContext) {
+    const domains = new Map();
+    for (const domain of readContext.model?.domains ?? []) {
+        if (!isMineableWalletDomain(readContext, domain)) {
+            continue;
+        }
+        domains.set(canonicalizeMiningDomainPromptName(domain.name), {
+            name: domain.name,
+            domainId: domain.domainId,
+        });
+    }
+    return domains;
+}
+function buildPromptEntries(options) {
+    const entries = new Map();
+    const mineableDomains = listMineableDomains(options.readContext);
+    for (const domain of mineableDomains.values()) {
+        const canonicalDomainName = canonicalizeMiningDomainPromptName(domain.name);
+        const prompt = options.domainExtraPrompts[canonicalDomainName] ?? null;
+        entries.set(canonicalDomainName, {
+            domain,
+            mineable: true,
+            prompt,
+            effectivePromptSource: prompt !== null
+                ? "domain"
+                : options.fallbackPromptConfigured
+                    ? "global-fallback"
+                    : "none",
+        });
+    }
+    for (const [domainName, prompt] of Object.entries(options.domainExtraPrompts)) {
+        if (entries.has(domainName)) {
+            continue;
+        }
+        const found = findWalletDomain(options.readContext, domainName);
+        entries.set(domainName, {
+            domain: {
+                name: domainName,
+                domainId: found?.domain.domainId ?? null,
+            },
+            mineable: false,
+            prompt,
+            effectivePromptSource: "domain",
+        });
+    }
+    return [...entries.values()].sort((left, right) => left.domain.name.localeCompare(right.domain.name));
+}
+function isMineableTarget(readContext, domainName) {
+    const domain = readContext.model?.domains.find((entry) => canonicalizeMiningDomainPromptName(entry.name) === domainName);
+    return domain === undefined ? false : isMineableWalletDomain(readContext, domain);
+}
+export async function inspectMiningDomainPromptState(options) {
+    const config = await loadClientConfig({
+        path: options.paths.clientConfigPath,
+        provider: options.provider,
+    });
+    return {
+        fallbackPromptConfigured: fallbackPromptConfigured(config),
+        prompts: buildPromptEntries({
+            readContext: options.readContext,
+            domainExtraPrompts: config?.mining.domainExtraPrompts ?? {},
+            fallbackPromptConfigured: fallbackPromptConfigured(config),
+        }),
+    };
+}
+export async function updateMiningDomainPrompt(options) {
+    const canonicalDomainName = canonicalizeMiningDomainPromptName(options.domainName);
+    const config = await loadClientConfig({
+        path: options.paths.clientConfigPath,
+        provider: options.provider,
+    });
+    const currentPrompts = {
+        ...(config?.mining.domainExtraPrompts ?? {}),
+    };
+    const existingPrompt = currentPrompts[canonicalDomainName] ?? null;
+    const mineable = isMineableTarget(options.readContext, canonicalDomainName);
+    const found = findWalletDomain(options.readContext, canonicalDomainName);
+    const nextPrompt = options.prompt === null || options.prompt.trim().length === 0
+        ? null
+        : options.prompt.trim();
+    if (!mineable && existingPrompt === null) {
+        throw new Error("mine_prompt_domain_not_mineable");
+    }
+    if (options.readContext.localState.walletRootId === null) {
+        throw new Error("wallet_uninitialized");
+    }
+    if (nextPrompt === null) {
+        delete currentPrompts[canonicalDomainName];
+    }
+    else {
+        currentPrompts[canonicalDomainName] = nextPrompt;
+    }
+    const nextConfig = config ?? createEmptyClientConfig();
+    nextConfig.mining.domainExtraPrompts = currentPrompts;
+    await saveClientConfig({
+        path: options.paths.clientConfigPath,
+        provider: options.provider,
+        secretReference: createWalletSecretReference(options.readContext.localState.walletRootId),
+        config: nextConfig,
+    });
+    return {
+        domain: {
+            name: canonicalDomainName,
+            domainId: found?.domain.domainId ?? null,
+        },
+        previousPrompt: existingPrompt,
+        prompt: nextPrompt,
+        status: nextPrompt === null ? "cleared" : "updated",
+        fallbackPromptConfigured: fallbackPromptConfigured(config),
+    };
+}

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

@@ -1,7 +1,8 @@
 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 { 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, MiningModelSelectionSource, MiningProviderConfigRecord, MiningProviderInspection, MiningRuntimeStatusV1, MiningServiceHealth, } from "./types.js";
+export type { ClientConfigV1, MiningControlPlaneView, MiningDomainPromptEntry, MiningDomainPromptListResult, MiningDomainPromptMutationResult, MiningEventRecord, MiningModelSelectionSource, MiningProviderConfigRecord, MiningProviderInspection, MiningRuntimeStatusV1, MiningServiceHealth, } from "./types.js";

package/dist/wallet/mining/index.js

@@ -1,4 +1,5 @@
 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 { appendMiningEvent, loadMiningRuntimeStatus, readMiningEvents, resolveRotatedMiningEventsPath, saveMiningRuntimeStatus, } from "./runtime-artifacts.js";

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

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
+import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, stopManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import type { ProgressOutputMode } from "../../bitcoind/types.js";
 import { type FixedWalletInput, type MutationSender, type WalletMutationRpcClient } from "../tx/common.js";
@@ -10,6 +10,7 @@ import { type WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import type { MiningStateRecord, OutpointRecord, WalletStateV1 } from "../types.js";
 import { requestMiningGenerationPreemption } from "./coordination.js";
+import { type MiningSentenceGenerationRequest } from "./sentences.js";
 import type { MiningControlPlaneView, MiningEventRecord, MiningRuntimeStatusV1 } from "./types.js";
 import { type MiningFollowVisualizerState, type MiningSentenceBoardEntry, MiningFollowVisualizer } from "./visualizer.js";
 type MiningRpcClient = WalletMutationRpcClient & {
@@ -94,6 +95,8 @@ interface MiningRunnerStatusOverrides {
     currentAbsoluteFeeSats?: number | null;
     currentBlockFeeSpentSats?: string;
     lastSuspendDetectedAtUnixMs?: number | null;
+    reconnectSettledUntilUnixMs?: number | null;
+    tipSettledUntilUnixMs?: number | null;
     providerState?: MiningRuntimeStatusV1["providerState"];
     corePublishState?: MiningRuntimeStatusV1["corePublishState"];
     currentPublishDecision?: string | null;
@@ -175,10 +178,19 @@ interface MiningLoopState {
     selectedCandidate: MiningCandidate | null;
     ui: MiningFollowVisualizerState;
     waitingNote: string | null;
+    bitcoinRecoveryFirstFailureAtUnixMs: number | null;
+    bitcoinRecoveryFirstUnreachableAtUnixMs: number | null;
+    bitcoinRecoveryLastRestartAttemptAtUnixMs: number | null;
+    bitcoinRecoveryServiceInstanceId: string | null;
+    bitcoinRecoveryProcessId: number | null;
+    reconnectSettledUntilUnixMs: number | null;
+    tipSettledUntilUnixMs: number | null;
 }
 export interface RunForegroundMiningOptions extends RunnerDependencies {
     dataDir: string;
     databasePath: string;
+    clientVersion?: string | null;
+    updateAvailable?: boolean;
     provider?: WalletSecretProvider;
     prompter: WalletPrompter;
     builtInSetupEnsured?: boolean;
@@ -224,6 +236,7 @@ export declare function resetMiningUiForTipForTesting(loopState: MiningLoopState
 export declare function resolveSettledBoardForTesting(options: {
     snapshotState: NonNullable<WalletReadContext["snapshot"]>["state"] | null | undefined;
     snapshotTipHeight: number | null;
+    snapshotTipPreviousHashHex?: string | null;
     nodeBestHeight: number | null;
 }): {
     settledBlockHeight: number | null;
@@ -273,7 +286,7 @@ export declare function createMiningPlanForTesting(options: {
         referencedBlockHashInternal: Uint8Array;
         targetBlockHeight: number;
     };
-    conflictOutpoint: OutpointRecord;
+    conflictOutpoint: OutpointRecord | null;
     allUtxos: Awaited<ReturnType<MiningRpcClient["listUnspent"]>>;
     feeRateSatVb: number;
 }): {
@@ -294,6 +307,19 @@ export declare function resolveMiningConflictOutpointForTesting(options: {
     state: WalletStateV1;
     allUtxos: Awaited<ReturnType<MiningRpcClient["listUnspent"]>>;
 }): OutpointRecord | null;
+export declare function buildMiningGenerationRequestForTesting(options: {
+    targetBlockHeight: number;
+    referencedBlockHashDisplay: string;
+    generatedAtUnixMs?: number;
+    requestId?: string;
+    domains: Array<{
+        domainId: number;
+        domainName: string;
+        requiredWords: [string, string, string, string, string];
+    }>;
+    domainExtraPrompts?: Record<string, string>;
+    extraPrompt?: string | null;
+}): MiningSentenceGenerationRequest;
 declare function publishCandidateOnce(options: {
     readContext: WalletReadContext & {
         localState: {
@@ -356,11 +382,15 @@ declare function runMiningLoop(options: {
     fetchImpl?: typeof fetch;
     openReadContext: typeof openWalletReadContext;
     attachService: typeof attachOrStartManagedBitcoindService;
+    probeService?: typeof probeManagedBitcoindService;
+    stopService?: typeof stopManagedBitcoindService;
     rpcFactory: (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
     stdout?: {
         write(chunk: string): void;
     };
     visualizer?: MiningFollowVisualizer;
+    nowImpl?: () => number;
+    sleepImpl?: typeof sleep;
 }): Promise<void>;
 declare function waitForBackgroundHealthy(paths: WalletRuntimePaths): Promise<MiningRuntimeStatusV1 | null>;
 export declare function runForegroundMining(options: RunForegroundMiningOptions): Promise<void>;
@@ -384,6 +414,7 @@ export declare function handleDetectedMiningRuntimeResumeForTesting(options: {
     detectedAtUnixMs: number;
     openReadContext: typeof openWalletReadContext;
     visualizer?: MiningFollowVisualizer;
+    loopState?: MiningLoopState;
 }): Promise<void>;
 export declare function takeOverMiningRuntimeForTesting(options: {
     paths: WalletRuntimePaths;
@@ -406,11 +437,36 @@ export declare function performMiningCycleForTesting(options: {
     fetchImpl?: typeof fetch;
     openReadContext: typeof openWalletReadContext;
     attachService: typeof attachOrStartManagedBitcoindService;
+    probeService?: typeof probeManagedBitcoindService;
+    stopService?: typeof stopManagedBitcoindService;
     rpcFactory: (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
     stdout?: {
         write(chunk: string): void;
     };
     loopState?: MiningLoopState;
+    nowImpl?: () => number;
+}): Promise<void>;
+export declare function runMiningLoopForTesting(options: {
+    dataDir: string;
+    databasePath: string;
+    provider: WalletSecretProvider;
+    paths: WalletRuntimePaths;
+    runMode: "foreground" | "background";
+    backgroundWorkerPid: number | null;
+    backgroundWorkerRunId: string | null;
+    signal?: AbortSignal;
+    fetchImpl?: typeof fetch;
+    openReadContext: typeof openWalletReadContext;
+    attachService: typeof attachOrStartManagedBitcoindService;
+    probeService?: typeof probeManagedBitcoindService;
+    stopService?: typeof stopManagedBitcoindService;
+    rpcFactory: (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
+    stdout?: {
+        write(chunk: string): void;
+    };
+    visualizer?: MiningFollowVisualizer;
+    nowImpl?: () => number;
+    sleepImpl?: typeof sleep;
 }): Promise<void>;
 export declare function buildPrePublishStatusOverridesForTesting(options: {
     state: WalletStateV1;