@cogcoin/client 1.0.1 → 1.1.0

package/dist/wallet/mining/runtime-artifacts.js

@@ -18,6 +18,7 @@ function normalizeLegacyMiningProviderState(raw) {
         case "unavailable":
         case "rate-limited":
         case "auth-error":
+        case "not-found":
             return raw;
         case "hook-error":
         case "n/a":

package/dist/wallet/mining/sentence-protocol.d.ts

@@ -16,6 +16,7 @@ export interface MiningSentenceGenerationRequestV1 {
         domainId: number;
         domainName: string;
         requiredWords: [string, string, string, string, string];
+        extraPrompt: string | null;
     }>;
 }
 export interface MiningSentenceCandidateV1 {

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

@@ -10,8 +10,8 @@ export interface MiningSentenceSourceOptions {
     fetchImpl?: typeof fetch;
 }
 declare class MiningProviderRequestError extends Error {
-    readonly providerState: "unavailable" | "rate-limited" | "auth-error";
-    constructor(providerState: "unavailable" | "rate-limited" | "auth-error", message: string);
+    readonly providerState: "unavailable" | "rate-limited" | "auth-error" | "not-found";
+    constructor(providerState: "unavailable" | "rate-limited" | "auth-error" | "not-found", message: string);
 }
 export declare function generateMiningSentences(request: MiningSentenceGenerationRequest, options: MiningSentenceSourceOptions): Promise<{
     candidates: MiningSentenceCandidateV1[];

package/dist/wallet/mining/sentences.js

@@ -1,6 +1,7 @@
 import { loadClientConfig } from "./config.js";
 import { MINING_BUILTIN_TIMEOUT_MS, } from "./constants.js";
 import { normalizeMiningSentenceResponse, parseStrictJsonValue, stripMarkdownCodeFence, } from "./sentence-protocol.js";
+import { resolveBuiltInProviderModel } from "./provider-model.js";
 class MiningProviderRequestError extends Error {
     providerState;
     constructor(providerState, message) {
@@ -9,6 +10,14 @@ class MiningProviderRequestError extends Error {
         this.providerState = providerState;
     }
 }
+function createBuiltInProviderNotFoundError(options) {
+    const providerName = options.provider === "anthropic" ? "Anthropic" : "OpenAI";
+    const providerLabel = `The built-in ${providerName} mining provider`;
+    const message = options.usingDefaultModel
+        ? `${providerLabel} returned HTTP 404 for default model "${options.model}". ${providerName} may no longer serve that model. Rerun \`cogcoin mine setup\` to choose a valid override.`
+        : `${providerLabel} returned HTTP 404 for model "${options.model}". The configured model override may be invalid. Rerun \`cogcoin mine setup\` to clear or correct it.`;
+    return new MiningProviderRequestError("not-found", message);
+}
 function buildSystemPrompt(extraPrompt) {
     const lines = [
         "You are helping generate candidate Cogcoin mining sentences.",
@@ -16,9 +25,13 @@ function buildSystemPrompt(extraPrompt) {
         "Every sentence must be a single natural-language sentence.",
         "Do not add commentary, markdown, or code fences.",
         "Do not invent domain IDs or request IDs.",
+        "Each rootDomains entry may include an extraPrompt that applies only to that domain.",
+        "If rootDomains[i].extraPrompt is present, use it only for candidates for that domainId.",
+        "If rootDomains[i].extraPrompt is null, fall back to the request-level extraPrompt when it is present.",
+        "Never apply one domain's prompt to another domain's candidates.",
     ];
     if (extraPrompt !== null && extraPrompt.trim().length > 0) {
-        lines.push(`Extra instruction: ${extraPrompt.trim()}`);
+        lines.push(`Request-level fallback instruction: ${extraPrompt.trim()}`);
     }
     return lines.join("\n");
 }
@@ -65,7 +78,7 @@ async function requestBuiltInSentences(options) {
     const providerSignal = createProviderSignal(options.signal, Math.min(MINING_BUILTIN_TIMEOUT_MS, options.request.limits.timeoutMs));
     try {
         if (options.provider === "openai") {
-            const model = options.modelOverride ?? "gpt-5.4-mini";
+            const { effectiveModel: model, usingDefaultModel } = resolveBuiltInProviderModel(options.provider, options.modelOverride);
             const response = await fetchImpl("https://api.openai.com/v1/responses", {
                 method: "POST",
                 headers: {
@@ -77,7 +90,7 @@ async function requestBuiltInSentences(options) {
                     input: [
                         {
                             role: "system",
-                            content: buildSystemPrompt(options.extraPrompt),
+                            content: buildSystemPrompt(options.request.extraPrompt),
                         },
                         {
                             role: "user",
@@ -93,6 +106,13 @@ async function requestBuiltInSentences(options) {
             if (response.status === 429) {
                 throw new MiningProviderRequestError("rate-limited", "The built-in OpenAI mining provider is rate limited.");
             }
+            if (response.status === 404) {
+                throw createBuiltInProviderNotFoundError({
+                    provider: options.provider,
+                    model,
+                    usingDefaultModel,
+                });
+            }
             if (!response.ok) {
                 throw new MiningProviderRequestError("unavailable", `The built-in OpenAI mining provider returned HTTP ${response.status}.`);
             }
@@ -106,7 +126,7 @@ async function requestBuiltInSentences(options) {
                 model,
             });
         }
-        const model = options.modelOverride ?? "claude-sonnet-4-20250514";
+        const { effectiveModel: model, usingDefaultModel } = resolveBuiltInProviderModel(options.provider, options.modelOverride);
         const response = await fetchImpl("https://api.anthropic.com/v1/messages", {
             method: "POST",
             headers: {
@@ -117,7 +137,7 @@ async function requestBuiltInSentences(options) {
             body: JSON.stringify({
                 model,
                 max_tokens: 1_200,
-                system: buildSystemPrompt(options.extraPrompt),
+                system: buildSystemPrompt(options.request.extraPrompt),
                 messages: [
                     {
                         role: "user",
@@ -133,6 +153,13 @@ async function requestBuiltInSentences(options) {
         if (response.status === 429) {
             throw new MiningProviderRequestError("rate-limited", "The built-in Anthropic mining provider is rate limited.");
         }
+        if (response.status === 404) {
+            throw createBuiltInProviderNotFoundError({
+                provider: options.provider,
+                model,
+                usingDefaultModel,
+            });
+        }
         if (!response.ok) {
             throw new MiningProviderRequestError("unavailable", `The built-in Anthropic mining provider returned HTTP ${response.status}.`);
         }
@@ -222,7 +249,6 @@ export async function generateMiningSentences(request, options) {
             provider: builtIn.provider,
             apiKey: builtIn.apiKey,
             modelOverride: builtIn.modelOverride,
-            extraPrompt: builtIn.extraPrompt ?? request.extraPrompt,
             request,
             fetchImpl: options.fetchImpl,
             signal: options.signal,

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

@@ -1,19 +1,47 @@
 import type { ManagedBitcoindHealth, ManagedIndexerTruthSource } from "../../bitcoind/types.js";
 export type MiningServiceHealth = "synced" | "catching-up" | "reorging" | "starting" | "stale-heartbeat" | "failed" | "schema-mismatch" | "service-version-mismatch" | "wallet-root-mismatch" | "unavailable";
 export type MiningProviderKind = "openai" | "anthropic";
+export type MiningModelSelectionSource = "catalog" | "custom" | "legacy-default" | "legacy-custom";
 export interface MiningProviderConfigRecord {
     provider: MiningProviderKind;
     apiKey: string;
     extraPrompt: string | null;
     modelOverride: string | null;
+    modelSelectionSource: MiningModelSelectionSource;
     updatedAtUnixMs: number;
 }
+export type MiningProviderConfigByProvider = Partial<Record<MiningProviderKind, MiningProviderConfigRecord>>;
 export interface ClientConfigV1 {
     schemaVersion: 1;
     mining: {
         builtIn: MiningProviderConfigRecord | null;
+        builtInByProvider?: MiningProviderConfigByProvider;
+        domainExtraPrompts: Record<string, string>;
     };
 }
+export interface MiningDomainPromptEntry {
+    domain: {
+        name: string;
+        domainId: number | null;
+    };
+    mineable: boolean;
+    prompt: string | null;
+    effectivePromptSource: "domain" | "global-fallback" | "none";
+}
+export interface MiningDomainPromptListResult {
+    fallbackPromptConfigured: boolean;
+    prompts: MiningDomainPromptEntry[];
+}
+export interface MiningDomainPromptMutationResult {
+    domain: {
+        name: string;
+        domainId: number | null;
+    };
+    previousPrompt: string | null;
+    prompt: string | null;
+    status: "updated" | "cleared";
+    fallbackPromptConfigured: boolean;
+}
 export interface MiningEventRecord {
     schemaVersion: 1;
     timestampUnixMs: number;
@@ -56,7 +84,7 @@ export interface MiningRuntimeStatusV1 {
     indexerReorgDepth: number | null;
     indexerTipAligned: boolean | null;
     corePublishState: "unknown" | "network-inactive" | "no-outbound-peers" | "ibd" | "mempool-loading" | "healthy" | null;
-    providerState: "ready" | "backoff" | "unavailable" | "rate-limited" | "auth-error" | null;
+    providerState: "ready" | "backoff" | "unavailable" | "rate-limited" | "auth-error" | "not-found" | null;
     lastSuspendDetectedAtUnixMs: number | null;
     reconnectSettledUntilUnixMs: number | null;
     tipSettledUntilUnixMs: number | null;
@@ -103,8 +131,14 @@ export interface MiningProviderInspection {
     provider: MiningProviderKind | null;
     status: "ready" | "missing" | "error";
     message: string | null;
+    modelId: string | null;
+    effectiveModel: string | null;
     modelOverride: string | null;
+    modelSelectionSource: MiningModelSelectionSource | null;
+    usingDefaultModel: boolean | null;
     extraPromptConfigured: boolean;
+    estimatedDailyCostUsd: number | null;
+    estimatedDailyCostDisplay: string | null;
 }
 export interface MiningControlPlaneView {
     runtime: MiningRuntimeStatusV1;

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

@@ -11,6 +11,7 @@ export interface MiningSentenceBoardEntry {
     rank: number;
     domainName: string;
     sentence: string;
+    requiredWords: readonly string[];
 }
 export interface MiningProvisionalSentenceEntry {
     domainName: string | null;
@@ -44,6 +45,8 @@ export declare class MiningFollowVisualizer {
         platform?: NodeJS.Platform;
         env?: NodeJS.ProcessEnv;
         clock?: RenderClock;
+        clientVersion?: string | null;
+        updateAvailable?: boolean;
         rendererFactory?: (stream: TtyRenderStream) => VisualizerRendererLike;
     });
     update(snapshot: MiningRuntimeStatusV1, uiState?: MiningFollowVisualizerState): void;

package/dist/wallet/mining/visualizer.js

@@ -1,9 +1,11 @@
 import { createBootstrapProgress } from "../../bitcoind/progress/formatting.js";
+import { normalizeInlineText, truncateLine } from "../../bitcoind/progress/formatting.js";
 import { advanceFollowSceneState, createFollowSceneState, replaceFollowBlockTimes, syncFollowSceneState, } from "../../bitcoind/progress/follow-scene.js";
 import { DEFAULT_RENDER_CLOCK, resolveTtyRenderPolicy, TtyRenderThrottle, } from "../../bitcoind/progress/render-policy.js";
 import { TtyProgressRenderer } from "../../bitcoind/progress/tty-renderer.js";
 const MINING_ARTWORK_COG_WIDTH = 22;
 const MINING_SENTENCE_BOARD_SIZE = 5;
+const MINING_SENTENCE_BOARD_WRAP_WIDTH = 80;
 function formatCogAmountWithDecimals(value, { maxFractionDigits, minFractionDigits, }) {
     const sign = value < 0n ? "-" : "";
     const absolute = value < 0n ? -value : value;
@@ -44,14 +46,86 @@ function formatCompactCogBalanceText(balanceCogtoshi) {
 function formatCompactSatBalanceText(balanceSats) {
     return balanceSats === null ? null : `${balanceSats.toString()} SAT`;
 }
+function formatArtworkVersionText(clientVersion) {
+    if (typeof clientVersion !== "string") {
+        return null;
+    }
+    const normalizedVersion = normalizeInlineText(clientVersion);
+    if (normalizedVersion.length === 0) {
+        return null;
+    }
+    return normalizedVersion.startsWith("v")
+        ? normalizedVersion
+        : `v${normalizedVersion}`;
+}
 function formatRewardCogAmount(value) {
     return `${formatCogAmountWithDecimals(value, {
         maxFractionDigits: 8,
         minFractionDigits: 1,
     })} COG`;
 }
-function formatSentenceRow(rank, domainName, sentence) {
-    return `${rank}. @${domainName}: ${sentence}`;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function consumeWrappedLine(text, capacity) {
+    const remaining = text.trimStart();
+    if (remaining.length <= capacity) {
+        return {
+            line: remaining,
+            remaining: "",
+        };
+    }
+    const candidate = remaining.slice(0, capacity + 1);
+    const breakIndex = candidate.lastIndexOf(" ");
+    if (breakIndex > 0) {
+        return {
+            line: remaining.slice(0, breakIndex).trimEnd(),
+            remaining: remaining.slice(breakIndex + 1).trimStart(),
+        };
+    }
+    return {
+        line: remaining.slice(0, capacity),
+        remaining: remaining.slice(capacity).trimStart(),
+    };
+}
+function highlightRequiredWords(sentence, requiredWords) {
+    const uniqueWords = [...new Set(requiredWords
+            .map((word) => word.trim().toLowerCase())
+            .filter((word) => word.length > 0))].sort((left, right) => right.length - left.length);
+    if (uniqueWords.length === 0) {
+        return sentence;
+    }
+    const pattern = new RegExp(`\\b(?:${uniqueWords.map(escapeRegExp).join("|")})\\b`, "gi");
+    return sentence.replace(pattern, (match) => match.toUpperCase());
+}
+function formatSentenceSlot(prefix, sentence, requiredWords, lineCount) {
+    if (sentence === null) {
+        return [
+            prefix.trimEnd(),
+            ...Array.from({ length: Math.max(0, lineCount - 1) }, () => ""),
+        ];
+    }
+    const normalizedSentence = highlightRequiredWords(normalizeInlineText(sentence), requiredWords);
+    const continuationPrefix = " ".repeat(prefix.length);
+    const lines = [];
+    let remaining = normalizedSentence;
+    for (let lineIndex = 0; lineIndex < lineCount; lineIndex += 1) {
+        const linePrefix = lineIndex === 0 ? prefix : continuationPrefix;
+        const capacity = Math.max(0, MINING_SENTENCE_BOARD_WRAP_WIDTH - linePrefix.length);
+        const wrapped = consumeWrappedLine(remaining, capacity);
+        const isLastLine = lineIndex === lineCount - 1;
+        const lineContent = isLastLine && wrapped.remaining.length > 0
+            ? truncateLine(`${wrapped.line}\u2026`, capacity)
+            : wrapped.line;
+        lines.push(lineContent.length === 0
+            ? ""
+            : `${linePrefix}${lineContent}`);
+        remaining = wrapped.remaining;
+    }
+    return lines;
+}
+function formatSentenceRow(entry) {
+    return formatSentenceSlot(`${entry.rank}. @${entry.domainName}: `, entry.sentence, entry.requiredWords, 2);
 }
 function formatRequiredWordsLine(words) {
     if (words.length === 0) {
@@ -59,11 +133,11 @@ function formatRequiredWordsLine(words) {
     }
     return `Required words: ${words.map((word) => word.toUpperCase()).join(", ")}`;
 }
-function formatProvisionalSentenceRow(entry) {
+function formatProvisionalSentenceRow(entry, requiredWords) {
     if (entry.domainName === null || entry.sentence === null) {
-        return "";
+        return ["", "", ""];
     }
-    return `@${entry.domainName}: ${entry.sentence}`;
+    return formatSentenceSlot(`@${entry.domainName}: `, entry.sentence, requiredWords, 3);
 }
 export function createEmptyMiningFollowVisualizerState() {
     return {
@@ -82,6 +156,34 @@ export function createEmptyMiningFollowVisualizerState() {
         recentWin: null,
     };
 }
+function cloneMiningRuntimeSnapshot(snapshot) {
+    return {
+        ...snapshot,
+    };
+}
+function cloneMiningFollowVisualizerState(state) {
+    return {
+        ...state,
+        visibleBlockTimesByHeight: { ...state.visibleBlockTimesByHeight },
+        settledBoardEntries: state.settledBoardEntries.map((entry) => ({
+            ...entry,
+            requiredWords: [...entry.requiredWords],
+        })),
+        provisionalRequiredWords: [...state.provisionalRequiredWords],
+        provisionalEntry: {
+            ...state.provisionalEntry,
+        },
+        recentWin: state.recentWin === null
+            ? null
+            : {
+                ...state.recentWin,
+            },
+    };
+}
+function miningFollowSceneShouldSettle(snapshot, nowUnixMs) {
+    return ((snapshot.tipSettledUntilUnixMs ?? 0) > nowUnixMs
+        || (snapshot.reconnectSettledUntilUnixMs ?? 0) > nowUnixMs);
+}
 const VISUALIZER_PROGRESS_SNAPSHOT = {
     url: "",
     filename: "mining-follow-visualizer",
@@ -172,6 +274,8 @@ export function describeMiningVisualizerProgress(snapshot) {
 }
 export class MiningFollowVisualizer {
     #renderer;
+    #artworkStatusLeftText;
+    #artworkStatusRightText;
     #clock;
     #renderThrottle;
     #progress = createBootstrapProgress("follow_tip", VISUALIZER_PROGRESS_SNAPSHOT);
@@ -187,6 +291,9 @@ export class MiningFollowVisualizer {
             env: options.env,
         });
         this.#clock = options.clock ?? DEFAULT_RENDER_CLOCK;
+        const artworkVersionText = formatArtworkVersionText(options.clientVersion);
+        this.#artworkStatusLeftText = options.updateAvailable === true ? "UPDATE" : null;
+        this.#artworkStatusRightText = artworkVersionText;
         this.#renderer = renderPolicy.enabled
             ? options.rendererFactory?.(stream) ?? new TtyProgressRenderer(stream)
             : null;
@@ -208,17 +315,20 @@ export class MiningFollowVisualizer {
         if (this.#renderer === null) {
             return;
         }
-        this.#latestSnapshot = snapshot;
+        this.#latestSnapshot = cloneMiningRuntimeSnapshot(snapshot);
         if (uiState !== undefined) {
-            this.#latestUiState = uiState;
+            this.#latestUiState = cloneMiningFollowVisualizerState(uiState);
         }
         replaceFollowBlockTimes(this.#scene, this.#latestUiState.visibleBlockTimesByHeight);
-        const indexedHeight = snapshot.indexerTipHeight ?? snapshot.coreBestHeight ?? null;
-        const nodeHeight = snapshot.coreBestHeight ?? indexedHeight;
+        const indexedHeight = this.#latestSnapshot.indexerTipHeight ?? this.#latestSnapshot.coreBestHeight ?? null;
+        const nodeHeight = this.#latestSnapshot.coreBestHeight ?? indexedHeight;
+        const settleLatest = miningFollowSceneShouldSettle(this.#latestSnapshot, this.#clock.now());
         syncFollowSceneState(this.#scene, {
             indexedHeight,
             nodeHeight,
             liveActivated: true,
+            authoritativeTip: true,
+            settleLatest,
         });
         this.#renderThrottle.request();
     }
@@ -252,7 +362,7 @@ export class MiningFollowVisualizer {
         this.#progress.targetHeight = nodeHeight;
         this.#progress.etaSeconds = null;
         this.#progress.lastError = snapshot.lastError;
-        this.#renderer.renderFollowScene(this.#progress, indexedHeight, nodeHeight, this.#scene, describeMiningVisualizerStatus(snapshot, uiState), {
+        const renderOptions = {
             artworkCogText: formatCompactCogBalanceText(uiState.balanceCogtoshi),
             artworkSatText: formatCompactSatBalanceText(uiState.balanceSats),
             extraLines: [
@@ -261,13 +371,20 @@ export class MiningFollowVisualizer {
                 ...Array.from({ length: MINING_SENTENCE_BOARD_SIZE }, (_value, index) => {
                     const entry = uiState.settledBoardEntries[index];
                     return entry === undefined
-                        ? `${index + 1}.`
-                        : formatSentenceRow(entry.rank, entry.domainName, entry.sentence);
-                }),
+                        ? [`${index + 1}.`, ""]
+                        : formatSentenceRow(entry);
+                }).flat(),
                 "----------",
                 formatRequiredWordsLine(uiState.provisionalRequiredWords),
-                formatProvisionalSentenceRow(uiState.provisionalEntry),
+                ...formatProvisionalSentenceRow(uiState.provisionalEntry, uiState.provisionalRequiredWords),
             ],
-        });
+        };
+        if (this.#artworkStatusLeftText !== null) {
+            renderOptions.artworkStatusLeftText = this.#artworkStatusLeftText;
+        }
+        if (this.#artworkStatusRightText !== null) {
+            renderOptions.artworkStatusRightText = this.#artworkStatusRightText;
+        }
+        this.#renderer.renderFollowScene(this.#progress, indexedHeight, nodeHeight, this.#scene, describeMiningVisualizerStatus(snapshot, uiState), renderOptions);
     }
 }

package/dist/wallet/read/context.d.ts

@@ -15,6 +15,7 @@ export declare function openWalletReadContext(options: {
     secretProvider?: WalletSecretProvider;
     walletControlLockHeld?: boolean;
     startupTimeoutMs?: number;
+    expectedIndexerBinaryVersion?: string | null;
     now?: number;
     paths?: WalletRuntimePaths;
 }): Promise<WalletReadContext>;

package/dist/wallet/read/context.js

@@ -1,6 +1,6 @@
 import { access, constants } from "node:fs/promises";
 import { deserializeIndexerState, loadBundledGenesisParameters } from "@cogcoin/indexer";
-import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, } from "../../bitcoind/indexer-daemon.js";
+import { attachOrStartIndexerDaemon, INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED, probeIndexerDaemon, readObservedIndexerDaemonStatus, readSnapshotWithRetry, } from "../../bitcoind/indexer-daemon.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { UNINITIALIZED_WALLET_ROOT_ID } from "../../bitcoind/service-paths.js";
 import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, } from "../../bitcoind/service.js";
@@ -245,6 +245,11 @@ function mapIndexerStartupError(message) {
                 health: "unavailable",
                 message: "The live indexer daemon socket responded with an invalid or incomplete protocol exchange.",
             };
+        case INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED:
+            return {
+                health: "failed",
+                message: "The managed indexer daemon could not recover automatic background follow.",
+            };
         default:
             return {
                 health: "unavailable",
@@ -532,17 +537,15 @@ export async function openWalletReadContext(options) {
             dataDir: options.dataDir,
             walletRootId,
         });
-        if (probe.compatibility === "compatible") {
-            daemonClient = probe.client;
-            observedDaemonStatus = probe.status;
-            indexerSource = "probe";
-        }
-        else if (probe.compatibility === "unreachable") {
+        if (probe.compatibility === "compatible" || probe.compatibility === "unreachable") {
+            await probe.client?.close().catch(() => undefined);
             daemonClient = await attachOrStartIndexerDaemon({
                 dataDir: options.dataDir,
                 databasePath: options.databasePath,
                 walletRootId,
                 startupTimeoutMs,
+                ensureBackgroundFollow: true,
+                expectedBinaryVersion: options.expectedIndexerBinaryVersion,
             });
         }
         else {
@@ -567,6 +570,11 @@ export async function openWalletReadContext(options) {
     }
     catch (error) {
         daemonError = error instanceof Error ? error.message : String(error);
+        if (daemonError === INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED) {
+            await daemonClient?.close().catch(() => undefined);
+            await node.handle?.stop().catch(() => undefined);
+            throw error;
+        }
         if (observedDaemonStatus === null) {
             observedDaemonStatus = await readObservedIndexerDaemonStatus({
                 dataDir: options.dataDir,

package/dist/wallet/state/client-password-agent.js

@@ -1,6 +1,9 @@
 import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
 import net from "node:net";
 import { rm } from "node:fs/promises";
+function shouldRemoveAgentEndpointPath(endpoint) {
+    return !endpoint.startsWith("\\\\.\\pipe\\");
+}
 function zeroizeBuffer(buffer) {
     if (buffer != null) {
         buffer.fill(0);
@@ -67,7 +70,7 @@ async function main() {
         }
         zeroizeBuffer(key);
         key = Buffer.alloc(0);
-        if (!bootstrap.endpoint.startsWith("\\\\.\\")) {
+        if (shouldRemoveAgentEndpointPath(bootstrap.endpoint)) {
             await rm(bootstrap.endpoint, { force: true }).catch(() => undefined);
         }
         process.exit(0);

package/dist/wallet/state/client-password.js

@@ -33,13 +33,18 @@ function resolveClientPasswordStatePath(directoryPath) {
 function resolveClientPasswordRotationJournalPath(directoryPath) {
     return join(directoryPath, "client-password-rotation.json");
 }
-function resolveAgentEndpoint(platform, stateRoot) {
+function resolveAgentEndpoint(stateRoot) {
     const hash = createHash("sha256").update(stateRoot).digest("hex").slice(0, 24);
-    if (platform === "win32") {
+    // Wallet provider tests simulate foreign platforms, but the local agent transport
+    // still has to follow the real host runtime.
+    if (process.platform === "win32") {
         return `\\\\.\\pipe\\cogcoin-client-password-${hash}`;
     }
     return join(tmpdir(), `cogcoin-client-password-${hash}.sock`);
 }
+function shouldRemoveAgentEndpointPath(endpoint) {
+    return !endpoint.startsWith("\\\\.\\pipe\\");
+}
 function isMissingFileError(error) {
     return error instanceof Error
         && "code" in error
@@ -352,7 +357,7 @@ async function openAgentConnection(endpoint) {
     });
 }
 async function requestAgent(options, request) {
-    const endpoint = resolveAgentEndpoint(options.platform, options.stateRoot);
+    const endpoint = resolveAgentEndpoint(options.stateRoot);
     const socket = await openAgentConnection(endpoint);
     return await new Promise((resolve, reject) => {
         let received = "";
@@ -418,8 +423,9 @@ async function requestAgentOrNull(options, request) {
             ? String(error.code ?? "")
             : "";
         if (code === "ENOENT" || code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EPIPE") {
-            if (options.platform !== "win32") {
-                await rm(resolveAgentEndpoint(options.platform, options.stateRoot), { force: true }).catch(() => undefined);
+            const endpoint = resolveAgentEndpoint(options.stateRoot);
+            if (shouldRemoveAgentEndpointPath(endpoint)) {
+                await rm(endpoint, { force: true }).catch(() => undefined);
             }
             return null;
         }
@@ -441,8 +447,9 @@ export async function readClientPasswordSessionStatus(options) {
 }
 export async function lockClientPasswordSession(options) {
     await requestAgentOrNull(options, { command: "lock" }).catch(() => null);
-    if (options.platform !== "win32") {
-        await rm(resolveAgentEndpoint(options.platform, options.stateRoot), { force: true }).catch(() => undefined);
+    const endpoint = resolveAgentEndpoint(options.stateRoot);
+    if (shouldRemoveAgentEndpointPath(endpoint)) {
+        await rm(endpoint, { force: true }).catch(() => undefined);
     }
     return {
         unlocked: false,
@@ -499,7 +506,7 @@ async function startClientPasswordSession(options) {
 }
 async function startClientPasswordSessionWithExpiry(options) {
     const unlockUntilUnixMs = options.unlockUntilUnixMs;
-    const endpoint = resolveAgentEndpoint(options.platform, options.stateRoot);
+    const endpoint = resolveAgentEndpoint(options.stateRoot);
     await lockClientPasswordSession(options).catch(() => undefined);
     await mkdir(options.runtimeRoot, { recursive: true }).catch(() => undefined);
     const child = spawn(process.execPath, [fileURLToPath(new URL("./client-password-agent.js", import.meta.url)), endpoint, String(unlockUntilUnixMs)], {

package/dist/wallet/tx/common.js

@@ -435,7 +435,7 @@ export async function buildWalletMutationTransaction(options) {
         const funded = await options.rpc.walletCreateFundedPsbt(options.walletName, options.plan.fixedInputs, options.plan.outputs, 0, {
             add_inputs: true,
             include_unsafe: false,
-            minconf: 1,
+            minconf: availableFundingMinConf,
             changeAddress: options.plan.changeAddress,
             ...(options.plan.changePosition == null ? {} : { changePosition: options.plan.changePosition }),
             lockUnspents: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogcoin/client",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Store-backed Cogcoin client with wallet flows, SQLite persistence, and managed Bitcoin Core integration.",
   "license": "MIT",
   "type": "module",
@@ -59,7 +59,8 @@
     "build": "rm -rf dist && node ./node_modules/typescript/bin/tsc -p tsconfig.json && node ./scripts/copy-static-assets.mjs build",
     "generate:default-snapshot-chunk-manifest": "node scripts/generate-default-snapshot-chunk-manifest.mjs",
     "verify:default-snapshot-chunk-manifest": "node scripts/generate-default-snapshot-chunk-manifest.mjs --check",
-    "test": "rm -rf .test-dist && node ./node_modules/typescript/bin/tsc -p tsconfig.test.json && node ./scripts/copy-static-assets.mjs test && node --test .test-dist/test/*.test.js"
+    "test": "rm -rf .test-dist && node ./node_modules/typescript/bin/tsc -p tsconfig.test.json && node ./scripts/copy-static-assets.mjs test && node --test .test-dist/test/*.test.js",
+    "test:mining": "rm -rf .test-dist && node ./node_modules/typescript/bin/tsc -p tsconfig.test-mining.json && node ./scripts/copy-static-assets.mjs test && node --test .test-dist/test/mining*.test.js"
   },
   "dependencies": {
     "@cogcoin/bitcoin": "30.2.0",