@cogcoin/client 1.0.1 → 1.1.0

package/dist/wallet/mining/provider-model.js

@@ -0,0 +1,134 @@
+const DEFAULT_BUILT_IN_PROVIDER_MODELS = {
+    openai: "gpt-5.4-mini",
+    anthropic: "claude-sonnet-4-20250514",
+};
+const RECOMMENDED_BUILT_IN_PROVIDER_MODELS = {
+    openai: "gpt-5.4-mini",
+    anthropic: "claude-sonnet-4-6",
+};
+const BUILT_IN_PROVIDER_MODEL_CATALOG = {
+    openai: [
+        {
+            label: "GPT-5.4",
+            modelId: "gpt-5.4",
+            inputUsdPerMillionTokens: 2.5,
+            outputUsdPerMillionTokens: 15,
+        },
+        {
+            label: "GPT-5.4 mini",
+            modelId: "gpt-5.4-mini",
+            inputUsdPerMillionTokens: 0.75,
+            outputUsdPerMillionTokens: 4.5,
+        },
+        {
+            label: "GPT-5.4 nano",
+            modelId: "gpt-5.4-nano",
+            inputUsdPerMillionTokens: 0.2,
+            outputUsdPerMillionTokens: 1.25,
+        },
+    ],
+    anthropic: [
+        {
+            label: "Claude Opus 4.7",
+            modelId: "claude-opus-4-7",
+            inputUsdPerMillionTokens: 5,
+            outputUsdPerMillionTokens: 25,
+        },
+        {
+            label: "Claude Sonnet 4.6",
+            modelId: "claude-sonnet-4-6",
+            inputUsdPerMillionTokens: 3,
+            outputUsdPerMillionTokens: 15,
+        },
+        {
+            label: "Claude Haiku 4.5",
+            modelId: "claude-haiku-4-5",
+            inputUsdPerMillionTokens: 1,
+            outputUsdPerMillionTokens: 5,
+        },
+    ],
+};
+const DAILY_COST_ESTIMATE_CALLS_PER_DAY = 144;
+const DAILY_COST_ESTIMATE_BASE_INPUT_TOKENS = 340;
+const DAILY_COST_ESTIMATE_PER_ROOT_INPUT_TOKENS = 85;
+const DAILY_COST_ESTIMATE_BASE_OUTPUT_TOKENS = 120;
+const DAILY_COST_ESTIMATE_PER_ROOT_OUTPUT_TOKENS = 105;
+export const MINING_MODEL_DAILY_COST_ESTIMATE_ASSUMPTION = "Approximate daily cost assumes 144 sentence-generation calls/day using your current anchored root count, standard token pricing, no caching, and no extra prompt.";
+function normalizeModelOverride(raw) {
+    if (typeof raw !== "string") {
+        return null;
+    }
+    const trimmed = raw.trim();
+    return trimmed.length === 0 ? null : trimmed;
+}
+export function getLegacyBuiltInProviderDefaultModel(provider) {
+    return DEFAULT_BUILT_IN_PROVIDER_MODELS[provider];
+}
+export function getRecommendedBuiltInProviderModel(provider) {
+    return RECOMMENDED_BUILT_IN_PROVIDER_MODELS[provider];
+}
+export function getBuiltInProviderModelCatalog(provider) {
+    return BUILT_IN_PROVIDER_MODEL_CATALOG[provider];
+}
+export function findBuiltInProviderModelCatalogEntry(provider, modelId) {
+    return BUILT_IN_PROVIDER_MODEL_CATALOG[provider].find((entry) => entry.modelId === modelId) ?? null;
+}
+export function normalizeMiningModelSelectionSource(raw, modelOverride) {
+    switch (raw) {
+        case "catalog":
+        case "custom":
+        case "legacy-default":
+        case "legacy-custom":
+            return raw;
+        default:
+            return modelOverride === null ? "legacy-default" : "legacy-custom";
+    }
+}
+export function normalizeMiningProviderConfigRecord(config) {
+    const modelOverride = normalizeModelOverride(config.modelOverride);
+    return {
+        ...config,
+        extraPrompt: typeof config.extraPrompt === "string" && config.extraPrompt.trim().length > 0
+            ? config.extraPrompt
+            : null,
+        modelOverride,
+        modelSelectionSource: normalizeMiningModelSelectionSource(config.modelSelectionSource, modelOverride),
+    };
+}
+export function resolveBuiltInProviderModel(provider, modelOverride) {
+    const normalizedModelOverride = normalizeModelOverride(modelOverride);
+    return {
+        effectiveModel: normalizedModelOverride ?? DEFAULT_BUILT_IN_PROVIDER_MODELS[provider],
+        usingDefaultModel: normalizedModelOverride === null,
+    };
+}
+export function resolveBuiltInProviderSelection(config) {
+    const modelOverride = normalizeModelOverride(config.modelOverride);
+    const modelSelectionSource = normalizeMiningModelSelectionSource(config.modelSelectionSource, modelOverride);
+    const { effectiveModel, usingDefaultModel } = resolveBuiltInProviderModel(config.provider, modelOverride);
+    return {
+        modelId: effectiveModel,
+        effectiveModel,
+        modelSelectionSource,
+        usingDefaultModel,
+    };
+}
+export function estimateBuiltInModelDailyCost(provider, modelId, eligibleRootCount) {
+    const model = findBuiltInProviderModelCatalogEntry(provider, modelId);
+    if (model === null) {
+        return null;
+    }
+    const rootCount = Math.max(0, Math.trunc(eligibleRootCount));
+    const estimatedInputTokens = DAILY_COST_ESTIMATE_BASE_INPUT_TOKENS
+        + (DAILY_COST_ESTIMATE_PER_ROOT_INPUT_TOKENS * rootCount);
+    const estimatedOutputTokens = DAILY_COST_ESTIMATE_BASE_OUTPUT_TOKENS
+        + (DAILY_COST_ESTIMATE_PER_ROOT_OUTPUT_TOKENS * rootCount);
+    const estimatedPerCallUsd = ((estimatedInputTokens / 1_000_000) * model.inputUsdPerMillionTokens) + ((estimatedOutputTokens / 1_000_000) * model.outputUsdPerMillionTokens);
+    const estimatedDailyCostUsd = Number((estimatedPerCallUsd * DAILY_COST_ESTIMATE_CALLS_PER_DAY).toFixed(6));
+    return {
+        estimatedDailyCostUsd,
+        estimatedDailyCostDisplay: estimatedDailyCostUsd < 0.005
+            ? "<$0.01/day"
+            : `$${estimatedDailyCostUsd.toFixed(2)}/day`,
+    };
+}

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

@@ -1,14 +1,18 @@
-import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
+import { spawn } from "node:child_process";
+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";
+import { readLockMetadata } from "../fs/lock.js";
 import type { WalletPrompter } from "../lifecycle.js";
 import { openWalletReadContext, type WalletReadContext } from "../read/index.js";
 import { type WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import type { MiningStateRecord, OutpointRecord, WalletStateV1 } from "../types.js";
-import type { MiningEventRecord, MiningRuntimeStatusV1 } from "./types.js";
-import { type MiningFollowVisualizerState, type MiningSentenceBoardEntry } from "./visualizer.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 & {
     getBlockchainInfo(): Promise<{
         blocks: number;
@@ -72,6 +76,41 @@ type MiningRpcClient = WalletMutationRpcClient & {
     sendRawTransaction(hex: string): Promise<string>;
     saveMempool?(): Promise<null>;
 };
+interface MiningRunnerStatusOverrides {
+    runMode?: MiningRuntimeStatusV1["runMode"];
+    backgroundWorkerPid?: number | null;
+    backgroundWorkerRunId?: string | null;
+    backgroundWorkerHeartbeatAtUnixMs?: number | null;
+    currentPhase?: MiningRuntimeStatusV1["currentPhase"];
+    currentPublishState?: MiningRuntimeStatusV1["currentPublishState"];
+    targetBlockHeight?: number | null;
+    referencedBlockHashDisplay?: string | null;
+    currentDomainId?: number | null;
+    currentDomainName?: string | null;
+    currentSentenceDisplay?: string | null;
+    currentCanonicalBlend?: string | null;
+    currentTxid?: string | null;
+    currentWtxid?: string | null;
+    currentFeeRateSatVb?: number | null;
+    currentAbsoluteFeeSats?: number | null;
+    currentBlockFeeSpentSats?: string;
+    lastSuspendDetectedAtUnixMs?: number | null;
+    reconnectSettledUntilUnixMs?: number | null;
+    tipSettledUntilUnixMs?: number | null;
+    providerState?: MiningRuntimeStatusV1["providerState"];
+    corePublishState?: MiningRuntimeStatusV1["corePublishState"];
+    currentPublishDecision?: string | null;
+    sameDomainCompetitorSuppressed?: boolean | null;
+    higherRankedCompetitorDomainCount?: number | null;
+    dedupedCompetitorDomainCount?: number | null;
+    competitivenessGateIndeterminate?: boolean | null;
+    mempoolSequenceCacheStatus?: MiningRuntimeStatusV1["mempoolSequenceCacheStatus"];
+    lastMempoolSequence?: string | null;
+    lastCompetitivenessGateAtUnixMs?: number | null;
+    lastError?: string | null;
+    note?: string | null;
+    livePublishInMempool?: boolean | null;
+}
 interface MiningCandidate {
     domainId: number;
     domainName: string;
@@ -97,8 +136,9 @@ type ReadyMiningReadContext = WalletReadContext & {
 interface MiningPublishSkipResult {
     state: WalletStateV1;
     txid: null;
-    decision: "publish-skipped-stale-candidate";
+    decision: "publish-skipped-stale-candidate" | "publish-paused-insufficient-funds";
     note: string;
+    lastError?: string | null;
     skipped: true;
     retryable?: false;
     candidate: null;
@@ -123,6 +163,13 @@ interface RunnerDependencies {
     attachService?: typeof attachOrStartManagedBitcoindService;
     rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => MiningRpcClient;
     fetchImpl?: typeof fetch;
+    requestMiningPreemption?: typeof requestMiningGenerationPreemption;
+    runMiningLoopImpl?: typeof runMiningLoop;
+    saveStopSnapshotImpl?: typeof saveStopSnapshot;
+    spawnWorkerProcess?: typeof spawn;
+    waitForBackgroundHealthyImpl?: typeof waitForBackgroundHealthy;
+    shutdownGraceMs?: number;
+    sleepImpl?: typeof sleep;
 }
 interface MiningLoopState {
     attemptedTipKey: string | null;
@@ -131,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;
@@ -168,11 +224,19 @@ export interface MiningStartResult {
     started: boolean;
     snapshot: MiningRuntimeStatusV1 | null;
 }
+interface MiningRuntimeTakeoverResult {
+    controlLockCleared: boolean;
+    replaced: boolean;
+    snapshot: MiningRuntimeStatusV1 | null;
+    terminatedPids: number[];
+}
+declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
 export declare function createMiningLoopStateForTesting(): MiningLoopState;
 export declare function resetMiningUiForTipForTesting(loopState: MiningLoopState, targetBlockHeight: number | null): void;
 export declare function resolveSettledBoardForTesting(options: {
     snapshotState: NonNullable<WalletReadContext["snapshot"]>["state"] | null | undefined;
     snapshotTipHeight: number | null;
+    snapshotTipPreviousHashHex?: string | null;
     nodeBestHeight: number | null;
 }): {
     settledBlockHeight: number | null;
@@ -222,7 +286,7 @@ export declare function createMiningPlanForTesting(options: {
         referencedBlockHashInternal: Uint8Array;
         targetBlockHeight: number;
     };
-    conflictOutpoint: OutpointRecord;
+    conflictOutpoint: OutpointRecord | null;
     allUtxos: Awaited<ReturnType<MiningRpcClient["listUnspent"]>>;
     feeRateSatVb: number;
 }): {
@@ -243,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: {
@@ -283,6 +360,39 @@ export declare function ensureBuiltInMiningSetupIfNeeded(options: {
     prompter: WalletPrompter;
     paths: WalletRuntimePaths;
 }): Promise<boolean>;
+declare function saveStopSnapshot(options: {
+    dataDir: string;
+    databasePath: string;
+    provider: WalletSecretProvider;
+    paths: WalletRuntimePaths;
+    runMode: "foreground" | "background";
+    backgroundWorkerPid: number | null;
+    backgroundWorkerRunId: string | null;
+    note: string | null;
+}): Promise<void>;
+declare function runMiningLoop(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>;
+declare function waitForBackgroundHealthy(paths: WalletRuntimePaths): Promise<MiningRuntimeStatusV1 | null>;
 export declare function runForegroundMining(options: RunForegroundMiningOptions): Promise<void>;
 export declare function startBackgroundMining(options: StartBackgroundMiningOptions): Promise<MiningStartResult>;
 export declare function stopBackgroundMining(options: StopBackgroundMiningOptions): Promise<MiningRuntimeStatusV1 | null>;
@@ -303,7 +413,18 @@ export declare function handleDetectedMiningRuntimeResumeForTesting(options: {
     backgroundWorkerRunId: string | null;
     detectedAtUnixMs: number;
     openReadContext: typeof openWalletReadContext;
+    visualizer?: MiningFollowVisualizer;
+    loopState?: MiningLoopState;
 }): Promise<void>;
+export declare function takeOverMiningRuntimeForTesting(options: {
+    paths: WalletRuntimePaths;
+    reason: string;
+    clearControlLockFile?: boolean;
+    controlLockMetadata?: Awaited<ReturnType<typeof readLockMetadata>>;
+    requestMiningPreemption?: typeof requestMiningGenerationPreemption;
+    shutdownGraceMs?: number;
+    sleepImpl?: typeof sleep;
+}): Promise<MiningRuntimeTakeoverResult>;
 export declare function performMiningCycleForTesting(options: {
     dataDir: string;
     databasePath: string;
@@ -316,12 +437,42 @@ 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;
+    candidate: MiningCandidate;
+}): MiningRunnerStatusOverrides;
+export declare function buildStatusSnapshotForTesting(view: MiningControlPlaneView, overrides?: MiningRunnerStatusOverrides): MiningRuntimeStatusV1;
 export declare function shouldKeepCurrentTipLivePublishForTesting(options: {
     liveState: MiningStateRecord;
     candidate: {