@cogcoin/client 1.0.2 → 1.1.1

package/dist/semver.js

@@ -0,0 +1,68 @@
+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;
+}

package/dist/wallet/lifecycle.js

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

@@ -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";