@cogcoin/client 1.1.6 → 1.1.7

package/dist/bitcoind/service.js

@@ -1,6 +1,6 @@
 import { randomBytes } from "node:crypto";
 import { execFile, spawn } from "node:child_process";
-import { access, constants, mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { access, constants, mkdir, readFile, rm } from "node:fs/promises";
 import { totalmem } from "node:os";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";
@@ -10,7 +10,9 @@ import { acquireFileLock, FileLockBusyError } from "../wallet/fs/lock.js";
 import { writeFileAtomic } from "../wallet/fs/atomic.js";
 import { writeRuntimeStatusFile } from "../wallet/fs/status-file.js";
 import { stopIndexerDaemonServiceWithLockHeld } from "./indexer-daemon.js";
-import { mapManagedBitcoindRuntimeProbeFailure, mapManagedBitcoindValidationError, resolveManagedBitcoindProbeDecision, validateManagedBitcoindObservedStatus, } from "./managed-runtime/bitcoind-policy.js";
+import { mapManagedBitcoindRuntimeProbeFailure, mapManagedBitcoindValidationError, validateManagedBitcoindObservedStatus, } from "./managed-runtime/bitcoind-policy.js";
+import { listManagedBitcoindStatusCandidates, readManagedBitcoindObservedStatus, } from "./managed-runtime/bitcoind-status.js";
+import { attachOrStartManagedBitcoindRuntime, probeManagedBitcoindRuntime, } from "./managed-runtime/bitcoind-runtime.js";
 import { readJsonFileIfPresent } from "./managed-runtime/status.js";
 import { createRpcClient, validateNodeConfigForTesting } from "./node.js";
 import { resolveManagedServicePaths, UNINITIALIZED_WALLET_ROOT_ID } from "./service-paths.js";
@@ -78,42 +80,6 @@ async function acquireFileLockWithRetry(lockPath, metadata, timeoutMs) {
 function getWalletReplicaName(walletRootId) {
     return `cogcoin-${walletRootId}`.replace(/[^a-zA-Z0-9._-]+/g, "-").slice(0, 63);
 }
-async function listManagedBitcoindStatusCandidates(options) {
-    const candidates = new Map();
-    const addCandidate = async (statusPath, allowDataDirMismatch = false) => {
-        const status = await readJsonFileIfPresent(statusPath);
-        if (status === null) {
-            return;
-        }
-        if (!allowDataDirMismatch && status.dataDir !== options.dataDir) {
-            return;
-        }
-        candidates.set(statusPath, status);
-    };
-    await addCandidate(options.expectedStatusPath, true);
-    try {
-        const entries = await readdir(options.runtimeRoot, {
-            withFileTypes: true,
-        });
-        for (const entry of entries) {
-            if (!entry.isDirectory()) {
-                continue;
-            }
-            const statusPath = join(options.runtimeRoot, entry.name, "bitcoind-status.json");
-            if (statusPath === options.expectedStatusPath) {
-                continue;
-            }
-            await addCandidate(statusPath);
-        }
-    }
-    catch {
-        // Missing runtime roots are handled by returning no candidates.
-    }
-    return [...candidates.entries()].map(([statusPath, status]) => ({
-        statusPath,
-        status,
-    }));
-}
 async function allocatePort() {
     return new Promise((resolve, reject) => {
         const server = net.createServer();
@@ -664,44 +630,19 @@ async function tryAttachExistingManagedBitcoindService(options) {
     const refreshed = await refreshManagedBitcoindStatus(probe.status, paths, options);
     return createNodeHandle(refreshed, paths, options, "attached");
 }
-async function waitForManagedBitcoindService(options, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const attached = await tryAttachExistingManagedBitcoindService(options).catch(() => null);
-        if (attached !== null) {
-            return attached;
-        }
-        await sleep(250);
-    }
-    throw new Error("managed_bitcoind_service_start_timeout");
-}
 export async function probeManagedBitcoindService(options) {
-    const walletRootId = options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-    const paths = resolveManagedServicePaths(options.dataDir ?? "", walletRootId);
-    const candidates = await listManagedBitcoindStatusCandidates({
+    const resolvedOptions = {
+        ...options,
         dataDir: options.dataDir ?? "",
-        runtimeRoot: paths.runtimeRoot,
-        expectedStatusPath: paths.bitcoindStatusPath,
-    });
-    const expectedCandidate = candidates.find((candidate) => candidate.statusPath === paths.bitcoindStatusPath) ?? null;
-    for (const candidate of candidates) {
-        if (!await isProcessAlive(candidate.status.processId)) {
-            continue;
-        }
-        return probeManagedBitcoindStatusCandidate(candidate.status, options, paths.walletRuntimeRoot);
-    }
-    if (expectedCandidate !== null) {
-        return {
-            compatibility: "unreachable",
-            status: expectedCandidate.status,
-            error: null,
-        };
-    }
-    return {
-        compatibility: "unreachable",
-        status: candidates[0]?.status ?? null,
-        error: null,
+        walletRootId: options.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID,
+        startupTimeoutMs: options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
     };
+    return probeManagedBitcoindRuntime(resolvedOptions, {
+        getPaths: (runtimeOptions) => resolveManagedServicePaths(runtimeOptions.dataDir, runtimeOptions.walletRootId),
+        listStatusCandidates: listManagedBitcoindStatusCandidates,
+        isProcessAlive,
+        probeStatusCandidate: probeManagedBitcoindStatusCandidate,
+    });
 }
 export async function attachOrStartManagedBitcoindService(options) {
     const resolvedOptions = {
@@ -716,42 +657,27 @@ export async function attachOrStartManagedBitcoindService(options) {
         walletRootId: resolvedOptions.walletRootId,
         shutdownTimeoutMs: resolvedOptions.shutdownTimeoutMs,
     }, async () => {
-        const existingProbe = await probeManagedBitcoindService(resolvedOptions);
-        const existingDecision = resolveManagedBitcoindProbeDecision(existingProbe);
-        if (existingDecision.action === "attach") {
-            const existing = await tryAttachExistingManagedBitcoindService(resolvedOptions);
-            if (existing !== null) {
-                return existing;
-            }
-            throw new Error("managed_bitcoind_protocol_error");
-        }
-        if (existingDecision.action === "reject") {
-            throw new Error(existingDecision.error ?? "managed_bitcoind_protocol_error");
-        }
-        const paths = resolveManagedServicePaths(resolvedOptions.dataDir ?? "", resolvedOptions.walletRootId);
-        try {
-            const lock = await acquireFileLock(paths.bitcoindLockPath, {
+        return attachOrStartManagedBitcoindRuntime({
+            ...resolvedOptions,
+            dataDir: resolvedOptions.dataDir ?? "",
+            walletRootId: resolvedOptions.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID,
+            startupTimeoutMs,
+        }, {
+            getPaths: (runtimeOptions) => resolveManagedServicePaths(runtimeOptions.dataDir, runtimeOptions.walletRootId),
+            listStatusCandidates: listManagedBitcoindStatusCandidates,
+            isProcessAlive,
+            probeStatusCandidate: probeManagedBitcoindStatusCandidate,
+            attachExisting: tryAttachExistingManagedBitcoindService,
+            acquireStartLock: async (runtimeOptions, paths) => acquireFileLock(paths.bitcoindLockPath, {
                 purpose: "managed-bitcoind-start",
-                walletRootId: resolvedOptions.walletRootId,
-                dataDir: resolvedOptions.dataDir,
-            });
-            try {
-                const liveProbe = await probeManagedBitcoindService(resolvedOptions);
-                const liveDecision = resolveManagedBitcoindProbeDecision(liveProbe);
-                if (liveDecision.action === "attach") {
-                    const reattached = await tryAttachExistingManagedBitcoindService(resolvedOptions);
-                    if (reattached !== null) {
-                        return reattached;
-                    }
-                    throw new Error("managed_bitcoind_protocol_error");
-                }
-                if (liveDecision.action === "reject") {
-                    throw new Error(liveDecision.error ?? "managed_bitcoind_protocol_error");
-                }
+                walletRootId: runtimeOptions.walletRootId,
+                dataDir: runtimeOptions.dataDir,
+            }),
+            startService: async (runtimeOptions, paths) => {
                 const bitcoindPath = await getBitcoindPath();
                 await verifyBitcoindVersion(bitcoindPath);
                 const binaryVersion = SUPPORTED_BITCOIND_VERSION;
-                await mkdir(resolvedOptions.dataDir ?? "", { recursive: true });
+                await mkdir(runtimeOptions.dataDir, { recursive: true });
                 const startManagedProcess = async (startOptions) => {
                     const runtimeConfig = await resolveRuntimeConfig(paths.bitcoindStatusPath, paths.bitcoindRuntimeConfigPath, startOptions);
                     await writeBitcoinConf(paths.bitcoinConfPath, startOptions, runtimeConfig);
@@ -793,16 +719,15 @@ export async function attachOrStartManagedBitcoindService(options) {
                         throw error;
                     }
                     const nowUnixMs = Date.now();
-                    const walletRootId = startOptions.walletRootId ?? UNINITIALIZED_WALLET_ROOT_ID;
-                    const walletReplica = await loadManagedWalletReplicaIfPresent(rpc, walletRootId, startOptions.dataDir ?? "");
+                    const walletReplica = await loadManagedWalletReplicaIfPresent(rpc, startOptions.walletRootId, startOptions.dataDir);
                     return createBitcoindServiceStatus({
                         binaryVersion,
                         serviceInstanceId: randomBytes(16).toString("hex"),
                         state: "ready",
                         processId: child.pid ?? null,
-                        walletRootId,
+                        walletRootId: startOptions.walletRootId,
                         chain: startOptions.chain,
-                        dataDir: startOptions.dataDir ?? "",
+                        dataDir: startOptions.dataDir,
                         runtimeRoot: paths.walletRuntimeRoot,
                         startHeight: startOptions.startHeight,
                         rpc: rpcConfig,
@@ -818,32 +743,25 @@ export async function attachOrStartManagedBitcoindService(options) {
                 };
                 let status;
                 try {
-                    status = await startManagedProcess(resolvedOptions);
+                    status = await startManagedProcess(runtimeOptions);
                 }
                 catch (error) {
-                    if (resolvedOptions.getblockArchivePath === undefined || resolvedOptions.getblockArchivePath === null) {
+                    if (runtimeOptions.getblockArchivePath === undefined || runtimeOptions.getblockArchivePath === null) {
                         throw error;
                     }
                     status = await startManagedProcess({
-                        ...resolvedOptions,
+                        ...runtimeOptions,
                         getblockArchivePath: null,
                         getblockArchiveEndHeight: null,
                         getblockArchiveSha256: null,
                     });
                 }
                 await writeBitcoindStatus(paths, status);
-                return createNodeHandle(status, paths, resolvedOptions, "started");
-            }
-            finally {
-                await lock.release();
-            }
-        }
-        catch (error) {
-            if (error instanceof FileLockBusyError) {
-                return waitForManagedBitcoindService(resolvedOptions, startupTimeoutMs);
-            }
-            throw error;
-        }
+                return createNodeHandle(status, resolveManagedServicePaths(runtimeOptions.dataDir, runtimeOptions.walletRootId), runtimeOptions, "started");
+            },
+            isLockBusyError: (error) => error instanceof FileLockBusyError,
+            sleep,
+        });
     });
 }
 export async function stopManagedBitcoindService(options) {
@@ -866,8 +784,10 @@ export async function stopManagedBitcoindService(options) {
     }
 }
 export async function readManagedBitcoindServiceStatusForTesting(dataDir, walletRootId = UNINITIALIZED_WALLET_ROOT_ID) {
-    const paths = resolveManagedServicePaths(dataDir, walletRootId);
-    return readJsonFileIfPresent(paths.bitcoindStatusPath);
+    return readManagedBitcoindObservedStatus({
+        dataDir,
+        walletRootId,
+    });
 }
 export async function shutdownManagedBitcoindServiceForTesting(options) {
     await stopManagedBitcoindService({

package/dist/cli/command-registry.d.ts

@@ -1,5 +1,5 @@
 export type CommandHandlerFamily = "status" | "update" | "sync" | "follow" | "client-admin" | "service-runtime" | "wallet-admin" | "wallet-read" | "wallet-mutation" | "mining-admin" | "mining-runtime" | "mining-read";
-export type CommandName = "init" | "reset" | "repair" | "update" | "sync" | "status" | "client-lock" | "client-change-password" | "client-unlock" | "follow" | "bitcoin-start" | "bitcoin-stop" | "bitcoin-status" | "bitcoin-transfer" | "indexer-start" | "indexer-stop" | "indexer-status" | "anchor" | "register" | "transfer" | "sell" | "unsell" | "buy" | "domain-endpoint-set" | "domain-endpoint-clear" | "domain-delegate-set" | "domain-delegate-clear" | "domain-miner-set" | "domain-miner-clear" | "domain-canonical" | "fields" | "field" | "field-create" | "field-set" | "field-clear" | "send" | "claim" | "reclaim" | "cog-lock" | "rep-give" | "rep-revoke" | "mine" | "mine-start" | "mine-stop" | "mine-setup" | "mine-prompt" | "mine-prompt-list" | "mine-status" | "mine-log" | "wallet-show-mnemonic" | "wallet-status" | "address" | "ids" | "balance" | "locks" | "domains" | "show";
+export type CommandName = "init" | "reset" | "repair" | "update" | "sync" | "status" | "client-change-password" | "follow" | "bitcoin-start" | "bitcoin-stop" | "bitcoin-status" | "bitcoin-transfer" | "indexer-start" | "indexer-stop" | "indexer-status" | "anchor" | "register" | "transfer" | "sell" | "unsell" | "buy" | "domain-endpoint-set" | "domain-endpoint-clear" | "domain-delegate-set" | "domain-delegate-clear" | "domain-miner-set" | "domain-miner-clear" | "domain-canonical" | "fields" | "field" | "field-create" | "field-set" | "field-clear" | "send" | "claim" | "reclaim" | "cog-lock" | "rep-give" | "rep-revoke" | "mine" | "mine-setup" | "mine-prompt" | "mine-prompt-list" | "mine-status" | "mine-log" | "wallet-show-mnemonic" | "wallet-status" | "address" | "ids" | "balance" | "locks" | "domains" | "show";
 type AliasMatchMode = "always" | "requires-arg" | "end-or-flag";
 interface HelpEntry {
     usage: string;

package/dist/cli/command-registry.js

@@ -31,38 +31,6 @@ const commandSpecs = [
             return "cogcoin update";
         },
     },
-    {
-        id: "client-unlock",
-        handlerFamily: "client-admin",
-        supportsYes: false,
-        supportsSatvb: false,
-        aliases: [{ tokens: ["client", "unlock"] }],
-        helpEntries: [
-            {
-                usage: "client unlock",
-                description: "Unlock password-protected local wallet secrets for a limited time",
-            },
-        ],
-        describeCommand() {
-            return "cogcoin client unlock";
-        },
-    },
-    {
-        id: "client-lock",
-        handlerFamily: "client-admin",
-        supportsYes: false,
-        supportsSatvb: false,
-        aliases: [{ tokens: ["client", "lock"] }],
-        helpEntries: [
-            {
-                usage: "client lock",
-                description: "Flush the cached client password unlock session",
-            },
-        ],
-        describeCommand() {
-            return "cogcoin client lock";
-        },
-    },
     {
         id: "client-change-password",
         handlerFamily: "client-admin",
@@ -308,38 +276,6 @@ const commandSpecs = [
             return "cogcoin mine";
         },
     },
-    {
-        id: "mine-start",
-        handlerFamily: "mining-runtime",
-        supportsYes: false,
-        supportsSatvb: false,
-        aliases: [{ tokens: ["mine", "start"] }],
-        helpEntries: [
-            {
-                usage: "mine start",
-                description: "Start the miner as a background worker",
-            },
-        ],
-        describeCommand() {
-            return "cogcoin mine start";
-        },
-    },
-    {
-        id: "mine-stop",
-        handlerFamily: "mining-runtime",
-        supportsYes: false,
-        supportsSatvb: false,
-        aliases: [{ tokens: ["mine", "stop"] }],
-        helpEntries: [
-            {
-                usage: "mine stop",
-                description: "Stop the active background miner",
-            },
-        ],
-        describeCommand() {
-            return "cogcoin mine stop";
-        },
-    },
     {
         id: "mine-setup",
         handlerFamily: "mining-admin",
@@ -949,6 +885,8 @@ const commandSpecs = [
     },
 ];
 const removedPathSpecs = [
+    { tokens: ["client", "unlock"], errorCode: "cli_client_unlock_removed" },
+    { tokens: ["client", "lock"], errorCode: "cli_client_lock_removed" },
     { tokens: ["restore"], errorCode: "cli_restore_removed" },
     { tokens: ["wallet", "delete"], errorCode: "cli_wallet_delete_removed" },
     { tokens: ["wallet", "restore"], errorCode: "cli_wallet_restore_removed" },

package/dist/cli/commands/client-admin.js

@@ -1,30 +1,15 @@
 import { writeLine } from "../io.js";
 import { writeHandledCliError } from "../output.js";
-import { changeClientPassword, lockClientPassword, unlockClientPassword, } from "../../wallet/state/provider.js";
+import { changeClientPassword, } from "../../wallet/state/provider.js";
 function createCommandPrompter(context) {
     return context.createPrompter();
 }
 export async function runClientAdminCommand(parsed, context) {
     try {
-        if (parsed.command === "client-lock") {
-            await lockClientPassword(context.walletSecretProvider);
-            writeLine(context.stdout, "Client locked.");
-            return 0;
-        }
-        if (parsed.command === "client-unlock") {
-            const prompter = createCommandPrompter(context);
-            const status = await unlockClientPassword(context.walletSecretProvider, prompter);
-            writeLine(context.stdout, status.unlockUntilUnixMs === null
-                ? "Client unlocked."
-                : `Client unlocked until ${new Date(status.unlockUntilUnixMs).toISOString()}.`);
-            return 0;
-        }
         if (parsed.command === "client-change-password") {
             const prompter = createCommandPrompter(context);
-            const status = await changeClientPassword(context.walletSecretProvider, prompter);
-            writeLine(context.stdout, status.unlockUntilUnixMs === null
-                ? "Client password changed."
-                : `Client password changed. Client unlocked until ${new Date(status.unlockUntilUnixMs).toISOString()}.`);
+            await changeClientPassword(context.walletSecretProvider, prompter);
+            writeLine(context.stdout, "Client password changed.");
             return 0;
         }
         writeLine(context.stderr, `client admin command not implemented: ${parsed.command}`);

package/dist/cli/commands/mining-runtime.js

@@ -1,12 +1,13 @@
 import { dirname } from "node:path";
 import { DEFAULT_SNAPSHOT_METADATA, resolveBootstrapPathsForTesting } from "../../bitcoind/bootstrap.js";
 import { createEmptyMiningFollowVisualizerState, MiningFollowVisualizer, } from "../../wallet/mining/visualizer.js";
+import { createMiningStopRequestedError } from "../../wallet/mining/stop.js";
 import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolution.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
+import { bindClientPasswordPromptSessionPolicy } from "../../wallet/state/client-password/session-policy.js";
 import { ManagedIndexerProgressObserver, assertManagedIndexerStatusRecoverable, isManagedIndexerCaughtUp, pollManagedIndexerUntilCaughtUp, } from "../managed-indexer-observer.js";
 import { usesTtyProgress, writeLine } from "../io.js";
 import { writeHandledCliError } from "../output.js";
-import { formatNextStepLines, getMineStopNextSteps, } from "../workflow-hints.js";
 import { createCloseSignalWatcher, waitForCompletionOrStop } from "../signals.js";
 import { createSyncProgressReporter } from "../sync-progress.js";
 import { PASSIVE_UPDATE_CHECK_TIMEOUT_MS, applyUpdateCheckResult, compareSemver, createEmptyUpdateCheckCache, fetchLatestPublishedVersion, isUpdateCheckDisabled, loadUpdateCheckCache, persistUpdateCheckCache, shouldRefreshUpdateCheck, } from "../update-service.js";
@@ -317,7 +318,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
         const packageVersion = await context.readPackageVersion();
         const runtimePaths = context.resolveWalletRuntimePaths();
         if (parsed.command === "mine") {
-            const prompter = context.createPrompter();
+            const prompter = bindClientPasswordPromptSessionPolicy(context.createPrompter(), "mining-indefinite");
             const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, prompter);
             const ttyProgressActive = usesTtyProgress(parsed.progressOutput, context.stderr);
             await ensureMiningProviderSetup({
@@ -368,7 +369,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
                     : false;
                 abortController = new AbortController();
                 onStop = () => {
-                    abortController?.abort();
+                    abortController?.abort(createMiningStopRequestedError());
                 };
                 context.signalSource.on("SIGINT", onStop);
                 context.signalSource.on("SIGTERM", onStop);
@@ -397,63 +398,6 @@ export async function runMiningRuntimeCommand(parsed, context) {
             }
             return 0;
         }
-        if (parsed.command === "mine-start") {
-            const prompter = createCommandPrompter(context);
-            const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, prompter);
-            await ensureMiningProviderSetup({
-                context,
-                provider,
-                prompter,
-                runtimePaths,
-            });
-            const preflightCode = await syncManagedMiningReadiness({
-                parsed,
-                context,
-                dataDir,
-                databasePath: dbPath,
-                expectedBinaryVersion: packageVersion,
-                provider,
-                runtimePaths,
-            });
-            if (preflightCode !== null) {
-                return preflightCode;
-            }
-            const result = await context.startBackgroundMining({
-                dataDir,
-                databasePath: dbPath,
-                provider,
-                prompter,
-                builtInSetupEnsured: true,
-                paths: runtimePaths,
-            });
-            if (!result.started) {
-                writeLine(context.stdout, "Background mining is already active.");
-                if (result.snapshot?.backgroundWorkerPid !== null && result.snapshot?.backgroundWorkerPid !== undefined) {
-                    writeLine(context.stdout, `Worker pid: ${result.snapshot.backgroundWorkerPid}`);
-                }
-                return 0;
-            }
-            writeLine(context.stdout, "Started background mining.");
-            if (result.snapshot?.backgroundWorkerPid !== null && result.snapshot?.backgroundWorkerPid !== undefined) {
-                writeLine(context.stdout, `Worker pid: ${result.snapshot.backgroundWorkerPid}`);
-            }
-            return 0;
-        }
-        if (parsed.command === "mine-stop") {
-            const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, context.createPrompter());
-            const snapshot = await context.stopBackgroundMining({
-                dataDir,
-                databasePath: dbPath,
-                provider,
-                paths: runtimePaths,
-            });
-            const nextSteps = getMineStopNextSteps();
-            writeLine(context.stdout, snapshot?.note ?? "Background mining was not active.");
-            for (const line of formatNextStepLines(nextSteps)) {
-                writeLine(context.stdout, line);
-            }
-            return 0;
-        }
         writeLine(context.stderr, `mining runtime command not implemented: ${parsed.command}`);
         return 1;
     }

package/dist/cli/commands/wallet-admin.js

@@ -1,17 +1,16 @@
 import { writeLine } from "../io.js";
 import { writeHandledCliError } from "../output.js";
 import { loadWelcomeArtText } from "../art.js";
-import { formatNextStepLines, getFundingQuickstartGuidance, getInitNextSteps, getSetupUnlockGuidanceLines, } from "../workflow-hints.js";
+import { formatNextStepLines, getFundingQuickstartGuidance, getInitUnlockGuidanceLines, getInitNextSteps, } from "../workflow-hints.js";
 import { createOwnedLockCleanupSignalWatcher, waitForCompletionOrStop, } from "../signals.js";
 import { runSyncCommand } from "./sync.js";
-import { CLIENT_PASSWORD_SETUP_AUTO_UNLOCK_SECONDS } from "../../wallet/state/client-password.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 function createCommandPrompter(context) {
     return context.createPrompter();
 }
 function getRepairWarnings(result) {
-    return result.miningResumeAction === "resume-failed"
-        ? [`Wallet repair succeeded, but background mining did not resume automatically: ${result.miningResumeError ?? "unknown error"}`]
+    return result.miningResumeAction === "skipped-background-mode-removed"
+        ? ["Background mining no longer resumes automatically after repair. Run `cogcoin mine` if you want mining resumed."]
         : [];
 }
 function getResetWarnings(result) {
@@ -20,7 +19,7 @@ function getResetWarnings(result) {
         : [];
 }
 function writeSetupUnlockGuidance(stdout) {
-    for (const line of getSetupUnlockGuidanceLines(CLIENT_PASSWORD_SETUP_AUTO_UNLOCK_SECONDS)) {
+    for (const line of getInitUnlockGuidanceLines()) {
         writeLine(stdout, line);
     }
 }
@@ -100,7 +99,8 @@ function formatResetResultText(result) {
 function isRepairMiningResumeActionOk(action) {
     return action === "none"
         || action === "skipped-not-resumable"
-        || action === "resumed-background";
+        || action === "skipped-post-repair-blocked"
+        || action === "skipped-background-mode-removed";
 }
 function buildRepairWarningEntries(result) {
     const entries = [];

package/dist/cli/context.js

@@ -13,7 +13,7 @@ import { initializeWallet, previewResetWallet, repairWallet, resetWallet, showWa
 import { resolveWalletRuntimePathsForTesting } from "../wallet/runtime.js";
 import { openWalletReadContext } from "../wallet/read/index.js";
 import { loadRawWalletStateEnvelope, loadWalletState } from "../wallet/state/storage.js";
-import { ensureBuiltInMiningSetupIfNeeded, followMiningLog, inspectMiningControlPlane, inspectMiningDomainPromptState, readMiningLog, runForegroundMining, setupBuiltInMining, startBackgroundMining, stopBackgroundMining, updateMiningDomainPrompt, } from "../wallet/mining/index.js";
+import { ensureBuiltInMiningSetupIfNeeded, followMiningLog, inspectMiningControlPlane, inspectMiningDomainPromptState, readMiningLog, runForegroundMining, setupBuiltInMining, updateMiningDomainPrompt, } from "../wallet/mining/index.js";
 import { createLazyDefaultWalletSecretProvider } from "../wallet/state/provider.js";
 import { anchorDomain, transferBitcoin, buyDomain, claimCogLock, clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, clearField, createField, giveReputation, lockCogToDomain, registerDomain, reclaimCogLock, revokeReputation, sendCog, setField, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, sellDomain, transferDomain, } from "../wallet/tx/index.js";
 import { createTerminalPrompter } from "./prompt.js";
@@ -93,8 +93,6 @@ export function createDefaultContext(overrides = {}) {
         inspectMiningDomainPromptState: overrides.inspectMiningDomainPromptState ?? inspectMiningDomainPromptState,
         ensureBuiltInMiningSetupIfNeeded: overrides.ensureBuiltInMiningSetupIfNeeded ?? ensureBuiltInMiningSetupIfNeeded,
         runForegroundMining: overrides.runForegroundMining ?? runForegroundMining,
-        startBackgroundMining: overrides.startBackgroundMining ?? startBackgroundMining,
-        stopBackgroundMining: overrides.stopBackgroundMining ?? stopBackgroundMining,
         setupBuiltInMining: overrides.setupBuiltInMining ?? setupBuiltInMining,
         updateMiningDomainPrompt: overrides.updateMiningDomainPrompt ?? updateMiningDomainPrompt,
         readMiningLog: overrides.readMiningLog ?? readMiningLog,

package/dist/cli/mining-json.d.ts

@@ -1,4 +1,4 @@
-import type { MiningControlPlaneView, MiningDomainPromptMutationResult, MiningRuntimeStatusV1 } from "../wallet/mining/index.js";
+import type { MiningControlPlaneView, MiningDomainPromptMutationResult } from "../wallet/mining/index.js";
 export declare function buildMineSetupData(view: MiningControlPlaneView): {
     resultType: "state-change";
     stateChange: {
@@ -8,27 +8,6 @@ export declare function buildMineSetupData(view: MiningControlPlaneView): {
     };
     state: Record<string, unknown>;
 };
-export declare function buildMineStartData(result: {
-    started: boolean;
-    snapshot: MiningRuntimeStatusV1 | null;
-}): {
-    resultType: "state-change";
-    stateChange: {
-        kind: string;
-        before: Record<string, unknown> | null;
-        after: Record<string, unknown> | null;
-    };
-    state: Record<string, unknown>;
-};
-export declare function buildMineStopData(snapshot: MiningRuntimeStatusV1 | null): {
-    resultType: "state-change";
-    stateChange: {
-        kind: string;
-        before: Record<string, unknown> | null;
-        after: Record<string, unknown> | null;
-    };
-    state: Record<string, unknown>;
-};
 export declare function buildMinePromptData(result: MiningDomainPromptMutationResult): {
     domain: {
         name: string;

package/dist/cli/mining-json.js

@@ -35,29 +35,6 @@ export function buildMineSetupData(view) {
         after,
     });
 }
-export function buildMineStartData(result) {
-    const after = {
-        started: result.started,
-        runtime: summarizeRuntime(result.snapshot),
-    };
-    return buildStateChangeData({
-        kind: "mine-start",
-        state: after,
-        after,
-    });
-}
-export function buildMineStopData(snapshot) {
-    const after = {
-        stopped: snapshot !== null,
-        runtime: summarizeRuntime(snapshot),
-        note: snapshot?.note ?? "Background mining was not active.",
-    };
-    return buildStateChangeData({
-        kind: "mine-stop",
-        state: after,
-        after,
-    });
-}
 export function buildMinePromptData(result) {
     return {
         domain: result.domain,

package/dist/cli/output.js

@@ -330,8 +330,8 @@ export function createCliErrorPresentation(errorCode, fallbackMessage, error) {
     if (errorCode === "wallet_client_password_locked") {
         return {
             what: "Client password is locked.",
-            why: "This command needs the password-protected local wallet secret, but no active unlock session is available.",
-            next: "Run `cogcoin client unlock`, or rerun the command in an interactive terminal so Cogcoin can prompt for the client password.",
+            why: "This command needs the password-protected local wallet secret, but this process does not currently hold an unlocked client-password session.",
+            next: "Rerun the command in an interactive terminal so Cogcoin can prompt for the client password. Separate CLI invocations no longer share unlocked state.",
         };
     }
     if (errorCode === "wallet_client_password_change_requires_tty") {
@@ -341,6 +341,20 @@ export function createCliErrorPresentation(errorCode, fallbackMessage, error) {
             next: "Run `cogcoin client change-password` in an interactive terminal.",
         };
     }
+    if (errorCode === "cli_client_unlock_removed") {
+        return {
+            what: "`client unlock` was removed.",
+            why: "Cogcoin no longer shares unlocked client-password sessions across separate CLI commands.",
+            next: "Rerun password-aware commands in an interactive terminal so Cogcoin can prompt for the client password when needed.",
+        };
+    }
+    if (errorCode === "cli_client_lock_removed") {
+        return {
+            what: "`client lock` was removed.",
+            why: "Cogcoin no longer keeps reusable unlocked client-password sessions after a command exits.",
+            next: "Fresh CLI invocations start locked automatically and prompt when wallet-local secrets are needed.",
+        };
+    }
     if (errorCode === "cli_restore_removed" || errorCode === "cli_wallet_restore_removed") {
         return {
             what: "Standalone restore commands were removed.",

package/dist/cli/parse.js

@@ -282,8 +282,6 @@ export function parseCliArgs(argv) {
         || command === "sync"
         || command === "follow"
         || command === "mine"
-        || command === "mine-start"
-        || command === "mine-stop"
         || command === "mine-setup"
         || command === "mine-prompt-list"
         || command === "mine-status"