@cogcoin/client 1.2.4 → 1.2.5

package/README.md

@@ -1,6 +1,6 @@
 # `@cogcoin/client`
 
-`@cogcoin/client@1.2.4` is the reference Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
+`@cogcoin/client@1.2.5` is the reference Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
 
 Use Node 22 or newer.
 
@@ -126,6 +126,10 @@ The published package depends on:
 
 `@cogcoin/vectors@1.0.1` is kept as a repository development dependency for conformance tests and is not part of the published runtime dependency surface.
 
+## Upgrade Notes For `1.2.5`
+
+`@cogcoin/client@1.2.5` keeps managed Bitcoin runtime settings in `bitcoin.conf` instead of duplicating RPC, P2P, wallet, and ZMQ settings on the `bitcoind` command line. This prevents duplicate `pubhashblock` and `pubrawtx` ZMQ registrations. Managed startup, repair, `bitcoin status`, and `status --live` also refresh runtime status after successful RPC/ZMQ checks so a stale `starting` status does not remain after Core is ready.
+
 ## Upgrade Notes For `1.2.4`
 
 `@cogcoin/client@1.2.4` treats a live managed Bitcoin Core process returning startup `-28 Loading block index...` as a normal `starting` state. `cogcoin mine` waits instead of repeatedly restarting the process, and `cogcoin repair` prints progress during long checks. If repair restarts a stale managed bitcoind to add raw transaction ZMQ support and Core is still loading, repair exits with a clear note to wait and rerun `cogcoin status` or `cogcoin mine`.
@@ -173,10 +177,12 @@ The installed `cogcoin` command covers the first-party local wallet and node wor
 - COG and reputation commands such as `send`, `cog lock`, `claim`, `reclaim`, `rep give`, and `rep revoke`
 - mining commands such as `mine`, `mine status`, `mine log`, `mine setup`, `mine prompt`, and `mine prompt list`
 
+`cogcoin status` is passive by default: it reads local SQLite/runtime status files without prompting for the client password, starting services, or making Bitcoin RPC calls. Use `cogcoin status --live` when you want the full RPC-backed wallet overview and balance report.
+
 Use `cogcoin mine prompt <domain>` to set or clear a per-domain mining prompt override for one anchored root domain, and `cogcoin mine prompt list` to inspect the current per-domain prompt state alongside the global fallback prompt.
 Interactive text invocations periodically check the npm registry for newer `@cogcoin/client` releases and print `npm install -g @cogcoin/client` when a newer version is available.
 Set `COGCOIN_DISABLE_UPDATE_CHECK=1` to disable the CLI update notice entirely.
-Ordinary `sync`, `follow`, and wallet-aware read/status flows detach from the managed Bitcoin and indexer services on exit instead of stopping them.
+Ordinary `sync`, `follow`, and wallet-aware live read flows detach from the managed Bitcoin and indexer services on exit instead of stopping them.
 Use the explicit `bitcoin ...` and `indexer ...` commands when you want direct service inspection or start/stop control.
 For provider-backed local wallets, normal reads, mutations, and mining setup flows load local wallet state on demand whenever the local secret provider is available.
 When no wallet exists yet, `cogcoin init` interactively lets you either create a new wallet or restore an existing one from a 24-word English BIP39 mnemonic, then continues into sync.

package/dist/bitcoind/managed-bitcoind-service-config.d.ts

@@ -26,5 +26,9 @@ export declare function writeManagedBitcoindRuntimeConfigFile(filePath: string,
 export declare function writeManagedBitcoindRuntimeConfigFileFromStatus(filePath: string, status: Pick<ManagedBitcoindServiceStatus, "chain" | "rpc" | "zmq" | "p2pPort" | "getblockArchiveEndHeight" | "getblockArchiveSha256">, dependencies?: ManagedBitcoindRuntimeConfigFileDeps): Promise<void>;
 export declare function writeBitcoinConfForTesting(filePath: string, options: ManagedBitcoindServiceOptions, runtimeConfig: ManagedBitcoindRuntimeConfig): Promise<void>;
 export declare function buildManagedServiceArgsForTesting(options: ManagedBitcoindServiceOptions, runtimeConfig: ManagedBitcoindRuntimeConfig): string[];
-export declare function waitForManagedBitcoindCookie(cookieFile: string, timeoutMs: number, sleepImpl: (ms: number) => Promise<void>): Promise<void>;
+export declare function waitForManagedBitcoindCookie(cookieFile: string, timeoutMs: number, sleepImpl: (ms: number) => Promise<void>, options?: {
+    now?: () => number;
+    progressIntervalMs?: number;
+    onProgress?: (elapsedMs: number) => void | Promise<void>;
+}): Promise<void>;
 export type { BitcoindRpcConfig, BitcoindZmqConfig, };

package/dist/bitcoind/managed-bitcoind-service-config.js

@@ -147,12 +147,14 @@ export async function writeBitcoinConfForTesting(filePath, options, runtimeConfi
     const walletDir = join(options.dataDir ?? "", "wallets");
     await mkdir(dirname(filePath), { recursive: true });
     await mkdir(walletDir, { recursive: true });
-    const lines = [
+    const commonLines = [
         "server=1",
         "prune=0",
+        `dbcache=${runtimeConfig.dbcacheMiB}`,
+    ];
+    const networkLines = [
         "dnsseed=1",
         "listen=0",
-        `dbcache=${runtimeConfig.dbcacheMiB}`,
         `rpcbind=${LOCAL_HOST}`,
         `rpcallowip=${LOCAL_HOST}`,
         `rpcport=${runtimeConfig.rpc.port}`,
@@ -161,25 +163,23 @@ export async function writeBitcoinConfForTesting(filePath, options, runtimeConfi
         `zmqpubrawtx=tcp://${LOCAL_HOST}:${runtimeConfig.zmqPort}`,
         `walletdir=${walletDir}`,
     ];
+    const lines = options.chain === "regtest"
+        ? [
+            ...commonLines,
+            "",
+            "[regtest]",
+            ...networkLines,
+        ]
+        : [
+            ...commonLines,
+            ...networkLines,
+        ];
     await writeFileAtomic(filePath, `${lines.join("\n")}\n`, { mode: 0o600 });
 }
 export function buildManagedServiceArgsForTesting(options, runtimeConfig) {
-    const walletDir = join(options.dataDir ?? "", "wallets");
     const args = [
         "-nosettings=1",
         `-datadir=${options.dataDir}`,
-        `-rpcbind=${LOCAL_HOST}`,
-        `-rpcallowip=${LOCAL_HOST}`,
-        `-rpcport=${runtimeConfig.rpc.port}`,
-        `-port=${runtimeConfig.p2pPort}`,
-        `-zmqpubhashblock=tcp://${LOCAL_HOST}:${runtimeConfig.zmqPort}`,
-        `-zmqpubrawtx=tcp://${LOCAL_HOST}:${runtimeConfig.zmqPort}`,
-        `-walletdir=${walletDir}`,
-        "-server=1",
-        "-prune=0",
-        "-dnsseed=1",
-        "-listen=0",
-        `-dbcache=${runtimeConfig.dbcacheMiB}`,
     ];
     if (options.chain === "regtest") {
         args.push("-chain=regtest");
@@ -189,14 +189,23 @@ export function buildManagedServiceArgsForTesting(options, runtimeConfig) {
     }
     return args;
 }
-export async function waitForManagedBitcoindCookie(cookieFile, timeoutMs, sleepImpl) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
+export async function waitForManagedBitcoindCookie(cookieFile, timeoutMs, sleepImpl, options = {}) {
+    const now = options.now ?? Date.now;
+    const progressIntervalMs = options.progressIntervalMs ?? 30_000;
+    const startedAt = now();
+    const deadline = startedAt + timeoutMs;
+    let lastProgressAt = startedAt;
+    while (now() < deadline) {
         try {
             await access(cookieFile, constants.R_OK);
             return;
         }
         catch {
+            const currentTime = now();
+            if (currentTime - lastProgressAt >= progressIntervalMs) {
+                await options.onProgress?.(Math.max(0, currentTime - startedAt));
+                lastProgressAt = currentTime;
+            }
             await sleepImpl(250);
         }
     }

package/dist/bitcoind/managed-bitcoind-service-lifecycle.js

@@ -218,7 +218,9 @@ export async function attachOrStartManagedBitcoindService(options) {
                     await writeManagedBitcoindRuntimeConfigFile(paths.bitcoindRuntimeConfigPath, runtimeConfig);
                     await writeManagedBitcoindStatus(paths, startingStatus);
                     try {
-                        await waitForManagedBitcoindRpcReady(rpc, rpcConfig.cookieFile, startOptions.chain, startupTimeoutMs);
+                        await waitForManagedBitcoindRpcReady(rpc, rpcConfig.cookieFile, startOptions.chain, startupTimeoutMs, {
+                            progress: startOptions.rpcReadyProgress,
+                        });
                         await validateNodeConfigForTesting(rpc, startOptions.chain, zmqConfig.endpoint, {
                             requireRawTxZmq: true,
                         });

package/dist/bitcoind/managed-bitcoind-service-status.d.ts

@@ -1,10 +1,16 @@
 import { createRpcClient } from "./node.js";
 import { resolveManagedServicePaths } from "./service-paths.js";
 import { type ManagedBitcoindObservedStatus, type ManagedBitcoindNodeHandle, type ManagedBitcoindServiceStatus, type ManagedCoreWalletReplicaStatus } from "./types.js";
-import type { ManagedBitcoindServiceOwnership, ManagedBitcoindServiceOptions, ManagedBitcoindServiceStopResult } from "./managed-bitcoind-service-types.js";
+import type { ManagedBitcoindRpcReadyProgressReporter, ManagedBitcoindServiceOwnership, ManagedBitcoindServiceOptions, ManagedBitcoindServiceStopResult } from "./managed-bitcoind-service-types.js";
 import { type BitcoindRpcConfig, type BitcoindZmqConfig } from "./managed-bitcoind-service-config.js";
 import type { ManagedBitcoindServiceProbeResult } from "./managed-runtime/types.js";
-export declare function waitForManagedBitcoindRpcReady(rpc: ReturnType<typeof createRpcClient>, cookieFile: string, expectedChain: "main" | "regtest", timeoutMs: number): Promise<void>;
+interface WaitForManagedBitcoindRpcReadyOptions {
+    progress?: ManagedBitcoindRpcReadyProgressReporter;
+    progressIntervalMs?: number;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare function waitForManagedBitcoindRpcReady(rpc: ReturnType<typeof createRpcClient>, cookieFile: string, expectedChain: "main" | "regtest", timeoutMs: number, options?: WaitForManagedBitcoindRpcReadyOptions): Promise<void>;
 export declare function createBitcoindServiceStatus(options: {
     binaryVersion: string;
     serviceInstanceId: string;
@@ -40,3 +46,4 @@ export declare function createManagedBitcoindNodeHandle(options: {
         shutdownTimeoutMs?: number;
     }): Promise<ManagedBitcoindServiceStopResult>;
 }): ManagedBitcoindNodeHandle;
+export {};

package/dist/bitcoind/managed-bitcoind-service-status.js

@@ -9,21 +9,70 @@ import { createMissingManagedWalletReplicaStatus, loadManagedWalletReplicaIfPres
 import { DEFAULT_MANAGED_BITCOIND_STARTUP_TIMEOUT_MS, isManagedBitcoindProcessAlive, sleep, } from "./managed-bitcoind-service-process.js";
 import { waitForManagedBitcoindCookie, } from "./managed-bitcoind-service-config.js";
 import { isManagedRpcWarmupError } from "./retryable-rpc.js";
-export async function waitForManagedBitcoindRpcReady(rpc, cookieFile, expectedChain, timeoutMs) {
-    await waitForManagedBitcoindCookie(cookieFile, timeoutMs, sleep);
-    const deadline = Date.now() + timeoutMs;
+function describeRpcReadyError(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    const warmupMatch = /^bitcoind_rpc_[^_]+_-28_(.+)$/u.exec(error.message);
+    if (warmupMatch !== null) {
+        return warmupMatch[1].replaceAll("_", " ");
+    }
+    return error.message;
+}
+export async function waitForManagedBitcoindRpcReady(rpc, cookieFile, expectedChain, timeoutMs, options = {}) {
+    const sleepImpl = options.sleep ?? sleep;
+    const now = options.now ?? Date.now;
+    const progressIntervalMs = options.progressIntervalMs ?? 30_000;
+    const startedAt = now();
+    await options.progress?.({
+        code: "bitcoind-rpc-wait",
+        message: "Waiting for Bitcoin Core RPC readiness...",
+        elapsedMs: 0,
+        lastError: null,
+    });
+    await waitForManagedBitcoindCookie(cookieFile, timeoutMs, sleepImpl, {
+        now,
+        progressIntervalMs,
+        onProgress: async (elapsedMs) => {
+            await options.progress?.({
+                code: "bitcoind-rpc-wait-progress",
+                message: `Still waiting for Bitcoin Core RPC readiness (${Math.floor(elapsedMs / 1000)}s elapsed). Last RPC state: cookie not ready.`,
+                elapsedMs,
+                lastError: "cookie not ready",
+            });
+        },
+    });
+    const deadline = now() + timeoutMs;
     let lastError = null;
-    while (Date.now() < deadline) {
+    let lastProgressAt = startedAt;
+    while (now() < deadline) {
         try {
             const info = await rpc.getBlockchainInfo();
             if (info.chain !== expectedChain) {
                 throw new Error(`bitcoind_chain_expected_${expectedChain}_got_${info.chain}`);
             }
+            await options.progress?.({
+                code: "bitcoind-rpc-ready",
+                message: "Bitcoin Core RPC is ready.",
+                elapsedMs: Math.max(0, now() - startedAt),
+                lastError: null,
+            });
             return;
         }
         catch (error) {
             lastError = error;
-            await sleep(250);
+            const currentTime = now();
+            if (currentTime - lastProgressAt >= progressIntervalMs) {
+                const lastErrorText = describeRpcReadyError(lastError);
+                await options.progress?.({
+                    code: "bitcoind-rpc-wait-progress",
+                    message: `Still waiting for Bitcoin Core RPC readiness (${Math.floor((currentTime - startedAt) / 1000)}s elapsed). Last RPC state: ${lastErrorText}.`,
+                    elapsedMs: Math.max(0, currentTime - startedAt),
+                    lastError: lastErrorText,
+                });
+                lastProgressAt = currentTime;
+            }
+            await sleepImpl(250);
         }
     }
     throw lastError instanceof Error ? lastError : new Error("bitcoind_rpc_timeout");
@@ -66,7 +115,9 @@ export async function probeManagedBitcoindStatusCandidate(status, options, runti
     }
     const rpc = createRpcClient(status.rpc);
     try {
-        await waitForManagedBitcoindRpcReady(rpc, status.rpc.cookieFile, status.chain, options.startupTimeoutMs ?? DEFAULT_MANAGED_BITCOIND_STARTUP_TIMEOUT_MS);
+        await waitForManagedBitcoindRpcReady(rpc, status.rpc.cookieFile, status.chain, options.startupTimeoutMs ?? DEFAULT_MANAGED_BITCOIND_STARTUP_TIMEOUT_MS, {
+            progress: options.rpcReadyProgress,
+        });
         await validateNodeConfigForTesting(rpc, status.chain, status.zmq.endpoint, {
             requireRawTxZmq: true,
         });
@@ -98,7 +149,9 @@ export async function refreshManagedBitcoindStatus(status, paths, options) {
     const rpc = createRpcClient(status.rpc);
     const targetWalletRootId = options.walletRootId ?? status.walletRootId;
     try {
-        await waitForManagedBitcoindRpcReady(rpc, status.rpc.cookieFile, status.chain, options.startupTimeoutMs ?? DEFAULT_MANAGED_BITCOIND_STARTUP_TIMEOUT_MS);
+        await waitForManagedBitcoindRpcReady(rpc, status.rpc.cookieFile, status.chain, options.startupTimeoutMs ?? DEFAULT_MANAGED_BITCOIND_STARTUP_TIMEOUT_MS, {
+            progress: options.rpcReadyProgress,
+        });
         await validateNodeConfigForTesting(rpc, status.chain, status.zmq.endpoint, {
             requireRawTxZmq: true,
         });

package/dist/bitcoind/managed-bitcoind-service-types.d.ts

@@ -1,4 +1,11 @@
 import type { InternalManagedBitcoindOptions } from "./types.js";
+export interface ManagedBitcoindRpcReadyProgressEvent {
+    code: "bitcoind-rpc-wait" | "bitcoind-rpc-wait-progress" | "bitcoind-rpc-ready";
+    message: string;
+    elapsedMs: number;
+    lastError: string | null;
+}
+export type ManagedBitcoindRpcReadyProgressReporter = (event: ManagedBitcoindRpcReadyProgressEvent) => void | Promise<void>;
 export interface ManagedWalletReplicaRpc {
     listWallets(): Promise<string[]>;
     loadWallet(walletName: string, loadOnStartup?: boolean): Promise<{
@@ -23,6 +30,7 @@ export type ManagedBitcoindServiceOptions = Pick<InternalManagedBitcoindOptions,
     getblockArchiveEndHeight?: number | null;
     getblockArchiveSha256?: string | null;
     serviceLifetime?: "persistent" | "ephemeral";
+    rpcReadyProgress?: ManagedBitcoindRpcReadyProgressReporter;
 };
 export type ResolvedManagedBitcoindServiceOptions = ManagedBitcoindServiceOptions & {
     dataDir: string;

package/dist/cli/command-registry.js

@@ -7,8 +7,8 @@ const commandSpecs = [
         aliases: [{ tokens: ["status"] }],
         helpEntries: [
             {
-                usage: "status",
-                description: "Show wallet-aware local service and chain status",
+                usage: "status [--live]",
+                description: "Show passive local status; use --live for RPC-backed wallet balance",
             },
         ],
         describeCommand() {

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

@@ -44,19 +44,33 @@ async function resolveEffectiveWalletRootId(context) {
         source: "default-uninitialized",
     }));
 }
+function createRpcReadyProgressReporter(context) {
+    return async (event) => {
+        writeLine(context.stdout, event.message);
+    };
+}
 async function inspectManagedBitcoindStatus(dataDir, context) {
     const resolution = await resolveEffectiveWalletRootId(context);
+    const rpcReadyProgress = createRpcReadyProgressReporter(context);
     const probe = await context.probeManagedBitcoindService({
         dataDir,
         chain: "main",
         startHeight: 0,
         walletRootId: resolution.walletRootId,
+        rpcReadyProgress,
     });
     let node = null;
     let nodeError = null;
+    let service = probe.status;
     if (probe.compatibility === "compatible" && probe.status !== null) {
         try {
-            const rpc = context.createBitcoinRpcClient(probe.status.rpc);
+            service = await context.refreshManagedBitcoindServiceStatus(probe.status, resolveManagedServicePaths(dataDir, resolution.walletRootId), {
+                dataDir,
+                chain: "main",
+                startHeight: 0,
+                walletRootId: resolution.walletRootId,
+            });
+            const rpc = context.createBitcoinRpcClient(service.rpc);
             const [blockchainInfo, networkInfo] = await Promise.all([
                 rpc.getBlockchainInfo(),
                 rpc.getNetworkInfo(),
@@ -82,7 +96,7 @@ async function inspectManagedBitcoindStatus(dataDir, context) {
         walletRootId: resolution.walletRootId,
         walletRootSource: resolution.source,
         compatibility: probe.compatibility,
-        service: probe.status,
+        service,
         node,
         nodeError,
     };
@@ -304,11 +318,13 @@ export async function runServiceRuntimeCommand(parsed, context) {
         }
         if (parsed.command === "bitcoin-start") {
             const resolution = await resolveEffectiveWalletRootId(context);
+            const rpcReadyProgress = createRpcReadyProgressReporter(context);
             const probe = await context.probeManagedBitcoindService({
                 dataDir,
                 chain: "main",
                 startHeight: 0,
                 walletRootId: resolution.walletRootId,
+                rpcReadyProgress,
             });
             const genesis = await loadBundledGenesisParameters();
             await context.attachManagedBitcoindService({
@@ -316,6 +332,7 @@ export async function runServiceRuntimeCommand(parsed, context) {
                 chain: "main",
                 startHeight: resolveCogcoinProcessingStartHeight(genesis),
                 walletRootId: resolution.walletRootId,
+                rpcReadyProgress: probe.compatibility === "compatible" ? undefined : rpcReadyProgress,
             });
             const bitcoindStatus = probe.compatibility === "compatible" ? "already-running" : "started";
             const payload = {
@@ -356,17 +373,20 @@ export async function runServiceRuntimeCommand(parsed, context) {
             const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
             await context.ensureDirectory(dirname(dbPath));
             const genesis = await loadBundledGenesisParameters();
+            const rpcReadyProgress = createRpcReadyProgressReporter(context);
             const bitcoindProbe = await context.probeManagedBitcoindService({
                 dataDir,
                 chain: "main",
                 startHeight: 0,
                 walletRootId: resolution.walletRootId,
+                rpcReadyProgress,
             });
             await context.attachManagedBitcoindService({
                 dataDir,
                 chain: "main",
                 startHeight: resolveCogcoinProcessingStartHeight(genesis),
                 walletRootId: resolution.walletRootId,
+                rpcReadyProgress: bitcoindProbe.compatibility === "compatible" ? undefined : rpcReadyProgress,
             });
             const indexerProbe = await context.probeIndexerDaemon({
                 dataDir,

package/dist/cli/commands/status.js

@@ -1,13 +1,19 @@
 import { dirname } from "node:path";
 import { formatBalanceReport, formatWalletOverviewReport } from "../wallet-format.js";
+import { formatStatusReport } from "../status-format.js";
 import { writeLine } from "../io.js";
 import { createTerminalPrompter } from "../prompt.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 export async function runStatusCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
     const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
-    const packageVersion = await context.readPackageVersion();
     const runtimePaths = context.resolveWalletRuntimePaths();
+    const packageVersion = await context.readPackageVersion();
+    if (!parsed.statusLive) {
+        const status = await context.inspectPassiveClientStatus(dbPath, dataDir, runtimePaths);
+        writeLine(context.stdout, formatStatusReport(status, packageVersion));
+        return 0;
+    }
     await context.ensureDirectory(dirname(dbPath));
     const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, context.createPrompter?.() ?? createTerminalPrompter(context.stdin, context.stdout));
     const readContext = await context.openWalletReadContext({

package/dist/cli/context.js

@@ -3,6 +3,7 @@ import { mkdir } from "node:fs/promises";
 import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, stopIndexerDaemonService, } from "../bitcoind/indexer-daemon.js";
 import { createRpcClient } from "../bitcoind/node.js";
 import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, stopManagedBitcoindService, } from "../bitcoind/service.js";
+import { refreshManagedBitcoindStatus } from "../bitcoind/managed-bitcoind-service-status.js";
 import { resolveDefaultBitcoindDataDirForTesting, resolveDefaultClientDatabasePathForTesting, resolveDefaultUpdateCheckStatePathForTesting, } from "../app-paths.js";
 import { openManagedBitcoindClient } from "../bitcoind/index.js";
 import { openManagedIndexerMonitor } from "../bitcoind/indexer-monitor.js";
@@ -106,6 +107,7 @@ export function createDefaultContext(overrides = {}) {
         }),
         attachManagedBitcoindService: overrides.attachManagedBitcoindService ?? attachOrStartManagedBitcoindService,
         probeManagedBitcoindService: overrides.probeManagedBitcoindService ?? probeManagedBitcoindService,
+        refreshManagedBitcoindServiceStatus: overrides.refreshManagedBitcoindServiceStatus ?? refreshManagedBitcoindStatus,
         stopManagedBitcoindService: overrides.stopManagedBitcoindService ?? stopManagedBitcoindService,
         createBitcoinRpcClient: overrides.createBitcoinRpcClient ?? createRpcClient,
         attachIndexerDaemon: overrides.attachIndexerDaemon ?? attachOrStartIndexerDaemon,

package/dist/cli/output/rules/cli-surface.js

@@ -77,6 +77,13 @@ export const cliSurfaceErrorRules = [
                 next: "Drop `--satvb` for this command, or use it with a wallet mutation command like `cogcoin register` or `cogcoin send`.",
             };
         }
+        if (errorCode === "cli_live_not_supported_for_command") {
+            return {
+                what: "This command does not support `--live`.",
+                why: "`--live` only applies to `cogcoin status`, where it opts into RPC-backed wallet and service checks.",
+                next: "Drop `--live`, or run `cogcoin status --live`.",
+            };
+        }
         if (errorCode === "cli_anchor_clear_removed") {
             return {
                 what: "`anchor clear` is no longer available.",

package/dist/cli/parse.js

@@ -37,6 +37,7 @@ export function parseCliArgs(argv) {
     let listLimit = null;
     let listAll = false;
     let follow = false;
+    let statusLive = false;
     for (let index = 0; index < argv.length; index += 1) {
         const token = argv[index];
         if (token === "--help") {
@@ -238,6 +239,10 @@ export function parseCliArgs(argv) {
             follow = true;
             continue;
         }
+        if (token === "--live") {
+            statusLive = true;
+            continue;
+        }
         if (token === "--yes") {
             assumeYes = true;
             continue;
@@ -448,6 +453,9 @@ export function parseCliArgs(argv) {
     if (follow && command !== "mine-log") {
         throw new Error("cli_follow_not_supported_for_command");
     }
+    if (statusLive && command !== "status") {
+        throw new Error("cli_live_not_supported_for_command");
+    }
     if (command === "mine-log" && follow && (listAll || listLimit !== null)) {
         throw new Error("cli_follow_limit_not_supported");
     }
@@ -502,5 +510,6 @@ export function parseCliArgs(argv) {
         listLimit,
         listAll,
         follow,
+        statusLive,
     };
 }

package/dist/cli/status-format.d.ts

@@ -1,2 +1,2 @@
-import type { inspectPassiveClientStatus } from "../passive-status.js";
-export declare function formatStatusReport(status: Awaited<ReturnType<typeof inspectPassiveClientStatus>>): string;
+import type { PassiveClientStatus } from "../passive-status.js";
+export declare function formatStatusReport(status: PassiveClientStatus, version: string): string;

package/dist/cli/status-format.js

@@ -1,48 +1,187 @@
+function row(ok, text) {
+    return { ok, text };
+}
+function formatMarker(ok) {
+    return ok ? "✓" : "✗";
+}
+function formatValue(value) {
+    return value === null || value === undefined || value === "" ? "none" : String(value);
+}
+function formatYesNo(value) {
+    return value ? "yes" : "no";
+}
 function formatBootstrapPercent(current, total) {
     if (total <= 0) {
         return "0.00";
     }
     return ((current / total) * 100).toFixed(2);
 }
-export function formatStatusReport(status) {
-    const lines = [
-        "Cogcoin Client Status",
-        `DB path: ${status.dbPath}`,
-        `Bitcoin datadir: ${status.bitcoinDataDir}`,
-        `Store exists: ${status.storeExists ? "yes" : "no"}`,
-        `Store initialized: ${status.storeInitialized ? "yes" : "no"}`,
+function formatSignedDelta(value) {
+    if (value > 0) {
+        return `+${value}`;
+    }
+    return String(value);
+}
+function formatSection(title, rows) {
+    return [
+        title,
+        ...rows.map((entry) => `${formatMarker(entry.ok)} ${entry.text}`),
+    ].join("\n");
+}
+function buildPathsRows(status) {
+    return [
+        row(true, `DB path: ${status.dbPath}`),
+        row(true, `Bitcoin datadir: ${status.bitcoinDataDir}`),
+    ];
+}
+function buildWalletRows(status) {
+    const rows = [
+        row(status.wallet.walletRootId !== null && status.wallet.error === null, `Wallet root: ${status.wallet.walletRootId ?? "unknown"} (${status.wallet.source})`),
+    ];
+    if (status.wallet.error !== null) {
+        rows.push(row(false, `Wallet root error: ${status.wallet.error}`));
+    }
+    return rows;
+}
+function buildLocalStoreRows(status) {
+    const rows = [
+        row(status.storeExists, `Store exists: ${formatYesNo(status.storeExists)}`),
+        row(status.storeInitialized, `Store initialized: ${formatYesNo(status.storeInitialized)}`),
     ];
     if (status.storeError !== null) {
-        lines.push(`Store error: ${status.storeError}`);
+        rows.push(row(false, `Store error: ${status.storeError}`));
     }
     if (status.indexedTip === null) {
-        lines.push("Indexed tip: none");
+        rows.push(row(false, "Indexed tip: none"));
     }
     else {
-        lines.push(`Indexed tip height: ${status.indexedTip.height}`);
-        lines.push(`Indexed tip hash: ${status.indexedTip.blockHashHex}`);
-        lines.push(`Indexed tip state hash: ${status.indexedTip.stateHashHex ?? "none"}`);
+        rows.push(row(true, `Indexed tip height: ${status.indexedTip.height}`));
+        rows.push(row(true, `Indexed tip hash: ${status.indexedTip.blockHashHex}`));
+        rows.push(row(status.indexedTip.stateHashHex !== null, `Indexed tip state hash: ${formatValue(status.indexedTip.stateHashHex)}`));
     }
     if (status.latestCheckpoint === null) {
-        lines.push("Latest checkpoint: none");
+        rows.push(row(false, "Latest checkpoint: none"));
     }
     else {
-        lines.push(`Latest checkpoint height: ${status.latestCheckpoint.height}`);
-        lines.push(`Latest checkpoint hash: ${status.latestCheckpoint.blockHashHex}`);
+        rows.push(row(true, `Latest checkpoint height: ${status.latestCheckpoint.height}`));
+        rows.push(row(true, `Latest checkpoint hash: ${status.latestCheckpoint.blockHashHex}`));
+    }
+    if (status.indexedTip !== null && status.indexer.appliedTipHeight !== null) {
+        const delta = status.indexedTip.height - status.indexer.appliedTipHeight;
+        rows.push(row(Math.abs(delta) <= 1, `Store/indexer height delta: ${formatSignedDelta(delta)}`));
     }
+    return rows;
+}
+function buildBootstrapRows(status) {
     if (status.bootstrap === null) {
-        lines.push("Bootstrap state: none");
+        return [row(false, "Bootstrap state: none")];
     }
-    else {
-        lines.push(`Bootstrap phase: ${status.bootstrap.phase}`);
-        lines.push(`Bootstrap download: ${status.bootstrap.downloadedBytes} / ${status.bootstrap.totalBytes} bytes (${formatBootstrapPercent(status.bootstrap.downloadedBytes, status.bootstrap.totalBytes)}%)`);
-        lines.push(`Bootstrap validated: ${status.bootstrap.validated ? "yes" : "no"}`);
-        lines.push(`Bootstrap loaded: ${status.bootstrap.loadTxOutSetComplete ? "yes" : "no"}`);
-        lines.push(`Bootstrap base height: ${status.bootstrap.baseHeight ?? "none"}`);
-        lines.push(`Bootstrap tip hash: ${status.bootstrap.tipHashHex ?? "none"}`);
-        lines.push(`Bootstrap snapshot height: ${status.bootstrap.snapshotHeight ?? "none"}`);
-        lines.push(`Bootstrap last error: ${status.bootstrap.lastError ?? "none"}`);
-    }
-    lines.push("Live node: not checked (passive status)");
-    return lines.join("\n");
+    return [
+        row(status.bootstrap.lastError === null, `Bootstrap phase: ${status.bootstrap.phase}`),
+        row(status.bootstrap.lastError === null, `Bootstrap download: ${status.bootstrap.downloadedBytes} / ${status.bootstrap.totalBytes} bytes (${formatBootstrapPercent(status.bootstrap.downloadedBytes, status.bootstrap.totalBytes)}%)`),
+        row(status.bootstrap.validated, `Bootstrap validated: ${formatYesNo(status.bootstrap.validated)}`),
+        row(status.bootstrap.loadTxOutSetComplete, `Bootstrap loaded: ${formatYesNo(status.bootstrap.loadTxOutSetComplete)}`),
+        row(status.bootstrap.baseHeight !== null, `Bootstrap base height: ${formatValue(status.bootstrap.baseHeight)}`),
+        row(status.bootstrap.tipHashHex !== null, `Bootstrap tip hash: ${formatValue(status.bootstrap.tipHashHex)}`),
+        row(status.bootstrap.snapshotHeight !== null, `Bootstrap snapshot height: ${formatValue(status.bootstrap.snapshotHeight)}`),
+        row(status.bootstrap.lastError === null, `Bootstrap last error: ${formatValue(status.bootstrap.lastError)}`),
+    ];
+}
+function buildManagedBitcoindRows(status) {
+    if (status.managedBitcoind.error !== null) {
+        return [
+            row(false, "Managed bitcoind: corrupt"),
+            row(false, `Managed bitcoind status path: ${formatValue(status.managedBitcoind.statusPath)}`),
+            row(false, `Managed bitcoind status error: ${status.managedBitcoind.error}`),
+        ];
+    }
+    if (!status.managedBitcoind.present) {
+        return [row(false, "Managed bitcoind: unavailable")];
+    }
+    return [
+        row(status.managedBitcoind.state === "ready", `Managed bitcoind: ${formatValue(status.managedBitcoind.state)}`),
+        row(status.managedBitcoind.processId !== null, `Managed bitcoind pid: ${formatValue(status.managedBitcoind.processId)}`),
+        row(status.managedBitcoind.walletRootId !== null, `Managed bitcoind wallet root: ${formatValue(status.managedBitcoind.walletRootId)}`),
+        row(status.managedBitcoind.heartbeatAtUnixMs !== null, `Managed bitcoind heartbeat: ${formatValue(status.managedBitcoind.heartbeatAtUnixMs)}`),
+        row(status.managedBitcoind.updatedAtUnixMs !== null, `Managed bitcoind updated: ${formatValue(status.managedBitcoind.updatedAtUnixMs)}`),
+        row(status.managedBitcoind.lastError === null, `Managed bitcoind last error: ${formatValue(status.managedBitcoind.lastError)}`),
+    ];
+}
+function buildIndexerRows(status) {
+    if (status.indexer.error !== null) {
+        return [
+            row(false, "Indexer: corrupt"),
+            row(false, `Indexer status path: ${formatValue(status.indexer.statusPath)}`),
+            row(false, `Indexer status error: ${status.indexer.error}`),
+        ];
+    }
+    if (!status.indexer.present) {
+        return [row(false, "Indexer: unavailable")];
+    }
+    const rows = [
+        row(status.indexer.state === "synced", `Indexer: ${formatValue(status.indexer.state)}`),
+        row(status.indexer.processId !== null, `Indexer pid: ${formatValue(status.indexer.processId)}`),
+        row(status.indexer.walletRootId !== null, `Indexer wallet root: ${formatValue(status.indexer.walletRootId)}`),
+        row(status.indexer.coreBestHeight !== null, `Indexer core best height: ${formatValue(status.indexer.coreBestHeight)}`),
+        row(status.indexer.appliedTipHeight !== null, `Indexer applied tip height: ${formatValue(status.indexer.appliedTipHeight)}`),
+        row(status.indexer.appliedTipHash !== null, `Indexer applied tip hash: ${formatValue(status.indexer.appliedTipHash)}`),
+        row(status.indexer.heartbeatAtUnixMs !== null, `Indexer heartbeat: ${formatValue(status.indexer.heartbeatAtUnixMs)}`),
+        row(status.indexer.updatedAtUnixMs !== null, `Indexer updated: ${formatValue(status.indexer.updatedAtUnixMs)}`),
+        row(status.indexer.lastError === null, `Indexer last error: ${formatValue(status.indexer.lastError)}`),
+    ];
+    if (status.indexer.coreBestHeight !== null && status.indexer.appliedTipHeight !== null) {
+        const lag = Math.max(0, status.indexer.coreBestHeight - status.indexer.appliedTipHeight);
+        rows.push(row(lag === 0, `Indexer lag: ${lag} blocks`));
+    }
+    return rows;
+}
+function buildManagedServicesRows(status) {
+    return [
+        ...buildManagedBitcoindRows(status),
+        ...buildIndexerRows(status),
+    ];
+}
+function buildMiningRows(status) {
+    if (status.mining.error !== null) {
+        return [
+            row(false, "Mining state: corrupt"),
+            row(false, `Mining status path: ${formatValue(status.mining.statusPath)}`),
+            row(false, `Mining status error: ${status.mining.error}`),
+        ];
+    }
+    if (!status.mining.present) {
+        return [row(false, "Mining state: unavailable")];
+    }
+    const miningHasError = status.mining.lastError !== null;
+    const needsBackgroundWorker = status.mining.runMode === "background";
+    return [
+        row(!miningHasError, `Mining run mode: ${formatValue(status.mining.runMode)}`),
+        row(!miningHasError, `Mining state: ${formatValue(status.mining.miningState)}`),
+        row(!miningHasError, `Mining phase: ${formatValue(status.mining.currentPhase)}`),
+        row(!needsBackgroundWorker || status.mining.backgroundWorkerPid !== null, `Mining background worker pid: ${formatValue(status.mining.backgroundWorkerPid)}`),
+        row(!needsBackgroundWorker || status.mining.backgroundWorkerHealth !== null, `Mining background worker health: ${formatValue(status.mining.backgroundWorkerHealth)}`),
+        row(status.mining.updatedAtUnixMs !== null, `Mining updated: ${formatValue(status.mining.updatedAtUnixMs)}`),
+        row(!miningHasError, `Mining last error: ${formatValue(status.mining.lastError)}`),
+        row(status.mining.note === null, `Mining note: ${formatValue(status.mining.note)}`),
+    ];
+}
+function buildPassiveModeRows() {
+    return [
+        row(true, "Live node: not checked"),
+        row(true, "Password prompt: not required"),
+        row(true, "RPC-backed balance: not checked"),
+    ];
+}
+export function formatStatusReport(status, version) {
+    return [
+        `⛭ Cogcoin Status v${version} (passive) ⛭`,
+        formatSection("Paths", buildPathsRows(status)),
+        formatSection("Wallet", buildWalletRows(status)),
+        formatSection("Local Store", buildLocalStoreRows(status)),
+        formatSection("Bootstrap", buildBootstrapRows(status)),
+        formatSection("Managed Services", buildManagedServicesRows(status)),
+        formatSection("Mining", buildMiningRows(status)),
+        formatSection("Passive Mode", buildPassiveModeRows()),
+        "Run cogcoin status --live for RPC-backed balance and full service verification.",
+    ].join("\n\n");
 }

package/dist/cli/types.d.ts

@@ -4,6 +4,7 @@ import { createRpcClient } from "../bitcoind/node.js";
 import type { ManagedBitcoindProgressEvent } from "../bitcoind/types.js";
 import { attachOrStartIndexerDaemon, probeIndexerDaemon, readObservedIndexerDaemonStatus, stopIndexerDaemonService } from "../bitcoind/indexer-daemon.js";
 import { attachOrStartManagedBitcoindService, probeManagedBitcoindService, stopManagedBitcoindService } from "../bitcoind/service.js";
+import type { refreshManagedBitcoindStatus } from "../bitcoind/managed-bitcoind-service-status.js";
 import { openSqliteStore } from "../sqlite/index.js";
 import type { ClientStoreAdapter } from "../types.js";
 import type { WalletRuntimePaths } from "../wallet/runtime.js";
@@ -64,6 +65,7 @@ export interface ParsedCliArgs {
     listLimit: number | null;
     listAll: boolean;
     follow: boolean;
+    statusLive: boolean;
 }
 export interface ManagedClientLike {
     syncToTip(): Promise<{
@@ -115,6 +117,7 @@ export interface CliRunnerContext {
     openManagedIndexerMonitor?: typeof openManagedIndexerMonitor;
     attachManagedBitcoindService?: typeof attachOrStartManagedBitcoindService;
     probeManagedBitcoindService?: typeof probeManagedBitcoindService;
+    refreshManagedBitcoindServiceStatus?: typeof refreshManagedBitcoindStatus;
     stopManagedBitcoindService?: typeof stopManagedBitcoindService;
     createBitcoinRpcClient?: typeof createRpcClient;
     attachIndexerDaemon?: typeof attachOrStartIndexerDaemon;

package/dist/passive-status.d.ts

@@ -1,3 +1,4 @@
+import type { WalletRuntimePaths } from "./wallet/runtime.js";
 interface PassiveTipStatus {
     height: number;
     blockHashHex: string;
@@ -22,15 +23,62 @@ interface PassiveBootstrapStatus {
     snapshotHeight: number | null;
     updatedAt: number | null;
 }
+export interface PassiveWalletStatus {
+    walletRootId: string | null;
+    source: "wallet-state" | "none" | "unreadable";
+    error: string | null;
+}
+export interface PassiveManagedBitcoindStatus {
+    statusPath: string | null;
+    present: boolean;
+    state: string | null;
+    processId: number | null;
+    walletRootId: string | null;
+    heartbeatAtUnixMs: number | null;
+    updatedAtUnixMs: number | null;
+    lastError: string | null;
+    error: string | null;
+}
+export interface PassiveIndexerStatus {
+    statusPath: string | null;
+    present: boolean;
+    state: string | null;
+    processId: number | null;
+    walletRootId: string | null;
+    coreBestHeight: number | null;
+    appliedTipHeight: number | null;
+    appliedTipHash: string | null;
+    heartbeatAtUnixMs: number | null;
+    updatedAtUnixMs: number | null;
+    lastError: string | null;
+    error: string | null;
+}
+export interface PassiveMiningStatus {
+    statusPath: string | null;
+    present: boolean;
+    runMode: string | null;
+    miningState: string | null;
+    currentPhase: string | null;
+    backgroundWorkerPid: number | null;
+    backgroundWorkerHealth: string | null;
+    updatedAtUnixMs: number | null;
+    lastError: string | null;
+    note: string | null;
+    error: string | null;
+}
 export interface PassiveClientStatus {
     dbPath: string;
     bitcoinDataDir: string;
+    wallet: PassiveWalletStatus;
     storeInitialized: boolean;
     storeExists: boolean;
     indexedTip: PassiveTipStatus | null;
     latestCheckpoint: PassiveCheckpointStatus | null;
     bootstrap: PassiveBootstrapStatus | null;
+    managedBitcoind: PassiveManagedBitcoindStatus;
+    indexer: PassiveIndexerStatus;
+    mining: PassiveMiningStatus;
     storeError: string | null;
 }
-export declare function inspectPassiveClientStatus(dbPath: string, bitcoinDataDir: string): Promise<PassiveClientStatus>;
+export declare function inspectPassiveClientStatus(dbPath: string, bitcoinDataDir: string, runtimePaths?: WalletRuntimePaths): Promise<PassiveClientStatus>;
 export {};

package/dist/passive-status.js

@@ -1,8 +1,10 @@
 import { readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
+import { resolveManagedServicePaths } from "./bitcoind/service-paths.js";
 import { openReadonlySqliteDatabase } from "./sqlite/driver.js";
 import { loadLatestCheckpoint } from "./sqlite/checkpoints.js";
 import { loadTipMeta } from "./sqlite/tip-meta.js";
+import { extractWalletRootIdHintFromWalletStateEnvelope, loadRawWalletStateEnvelope, } from "./wallet/state/storage.js";
 function fileExists(path) {
     return stat(path).then(() => true, () => false);
 }
@@ -21,6 +23,193 @@ function readBootstrapState(raw) {
         updatedAt: parsed.updatedAt ?? null,
     };
 }
+function formatUnknownError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isMissingFileError(error) {
+    return error instanceof Error
+        && "code" in error
+        && error.code === "ENOENT";
+}
+async function inspectWalletStatus(runtimePaths) {
+    if (runtimePaths === undefined) {
+        return {
+            walletRootId: null,
+            source: "none",
+            error: null,
+        };
+    }
+    try {
+        const raw = await loadRawWalletStateEnvelope({
+            primaryPath: runtimePaths.walletStatePath,
+            backupPath: runtimePaths.walletStateBackupPath,
+        });
+        if (raw === null) {
+            return {
+                walletRootId: null,
+                source: "none",
+                error: null,
+            };
+        }
+        return {
+            walletRootId: extractWalletRootIdHintFromWalletStateEnvelope(raw.envelope),
+            source: "wallet-state",
+            error: null,
+        };
+    }
+    catch (error) {
+        return {
+            walletRootId: null,
+            source: "unreadable",
+            error: formatUnknownError(error),
+        };
+    }
+}
+async function readRuntimeStatusFile(statusPath) {
+    if (statusPath === null) {
+        return {
+            status: null,
+            present: false,
+            error: null,
+        };
+    }
+    try {
+        return {
+            status: JSON.parse(await readFile(statusPath, "utf8")),
+            present: true,
+            error: null,
+        };
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return {
+                status: null,
+                present: false,
+                error: null,
+            };
+        }
+        return {
+            status: null,
+            present: true,
+            error: formatUnknownError(error),
+        };
+    }
+}
+function emptyManagedBitcoindStatus(statusPath, present, error) {
+    return {
+        statusPath,
+        present,
+        state: null,
+        processId: null,
+        walletRootId: null,
+        heartbeatAtUnixMs: null,
+        updatedAtUnixMs: null,
+        lastError: null,
+        error,
+    };
+}
+function emptyIndexerStatus(statusPath, present, error) {
+    return {
+        statusPath,
+        present,
+        state: null,
+        processId: null,
+        walletRootId: null,
+        coreBestHeight: null,
+        appliedTipHeight: null,
+        appliedTipHash: null,
+        heartbeatAtUnixMs: null,
+        updatedAtUnixMs: null,
+        lastError: null,
+        error,
+    };
+}
+function emptyMiningStatus(statusPath, present, error) {
+    return {
+        statusPath,
+        present,
+        runMode: null,
+        miningState: null,
+        currentPhase: null,
+        backgroundWorkerPid: null,
+        backgroundWorkerHealth: null,
+        updatedAtUnixMs: null,
+        lastError: null,
+        note: null,
+        error,
+    };
+}
+function resolvePassiveServiceStatusPaths(bitcoinDataDir, runtimePaths, walletRootId) {
+    if (walletRootId !== null) {
+        const servicePaths = resolveManagedServicePaths(bitcoinDataDir, walletRootId);
+        return {
+            bitcoindStatusPath: servicePaths.bitcoindStatusPath,
+            indexerStatusPath: servicePaths.indexerDaemonStatusPath,
+            miningStatusPath: runtimePaths?.miningStatusPath ?? null,
+        };
+    }
+    return {
+        bitcoindStatusPath: runtimePaths?.bitcoindStatusPath ?? null,
+        indexerStatusPath: runtimePaths?.indexerStatusPath ?? null,
+        miningStatusPath: runtimePaths?.miningStatusPath ?? null,
+    };
+}
+async function inspectManagedBitcoindStatus(statusPath) {
+    const result = await readRuntimeStatusFile(statusPath);
+    if (result.status === null) {
+        return emptyManagedBitcoindStatus(statusPath, result.present, result.error);
+    }
+    return {
+        statusPath,
+        present: true,
+        state: result.status.state ?? null,
+        processId: result.status.processId ?? null,
+        walletRootId: result.status.walletRootId ?? null,
+        heartbeatAtUnixMs: result.status.heartbeatAtUnixMs ?? null,
+        updatedAtUnixMs: result.status.updatedAtUnixMs ?? null,
+        lastError: result.status.lastError ?? null,
+        error: null,
+    };
+}
+async function inspectIndexerStatus(statusPath) {
+    const result = await readRuntimeStatusFile(statusPath);
+    if (result.status === null) {
+        return emptyIndexerStatus(statusPath, result.present, result.error);
+    }
+    return {
+        statusPath,
+        present: true,
+        state: result.status.state ?? null,
+        processId: result.status.processId ?? null,
+        walletRootId: result.status.walletRootId ?? null,
+        coreBestHeight: result.status.coreBestHeight ?? null,
+        appliedTipHeight: result.status.appliedTipHeight ?? null,
+        appliedTipHash: result.status.appliedTipHash ?? null,
+        heartbeatAtUnixMs: result.status.heartbeatAtUnixMs ?? null,
+        updatedAtUnixMs: result.status.updatedAtUnixMs ?? null,
+        lastError: result.status.lastError ?? null,
+        error: null,
+    };
+}
+async function inspectMiningStatus(statusPath) {
+    const result = await readRuntimeStatusFile(statusPath);
+    if (result.status === null) {
+        return emptyMiningStatus(statusPath, result.present, result.error);
+    }
+    return {
+        statusPath,
+        present: true,
+        runMode: result.status.runMode ?? null,
+        miningState: result.status.miningState ?? null,
+        currentPhase: result.status.currentPhase ?? null,
+        backgroundWorkerPid: result.status.backgroundWorkerPid ?? null,
+        backgroundWorkerHealth: result.status.backgroundWorkerHealth ?? null,
+        updatedAtUnixMs: result.status.updatedAtUnixMs ?? null,
+        lastError: result.status.lastError ?? null,
+        note: result.status.note ?? null,
+        error: null,
+    };
+}
 async function inspectSqliteStore(dbPath) {
     const database = await openReadonlySqliteDatabase(dbPath);
     try {
@@ -50,9 +239,14 @@ async function inspectSqliteStore(dbPath) {
         await database.close();
     }
 }
-export async function inspectPassiveClientStatus(dbPath, bitcoinDataDir) {
+export async function inspectPassiveClientStatus(dbPath, bitcoinDataDir, runtimePaths) {
     const storeExists = await fileExists(dbPath);
     const bootstrapPath = join(bitcoinDataDir, "bootstrap", "state.json");
+    const wallet = await inspectWalletStatus(runtimePaths);
+    const statusPaths = resolvePassiveServiceStatusPaths(bitcoinDataDir, runtimePaths, wallet.walletRootId);
+    const managedBitcoind = await inspectManagedBitcoindStatus(statusPaths.bitcoindStatusPath);
+    const indexer = await inspectIndexerStatus(statusPaths.indexerStatusPath);
+    const mining = await inspectMiningStatus(statusPaths.miningStatusPath);
     let bootstrap = null;
     try {
         bootstrap = readBootstrapState(await readFile(bootstrapPath, "utf8"));
@@ -64,11 +258,15 @@ export async function inspectPassiveClientStatus(dbPath, bitcoinDataDir) {
         return {
             dbPath,
             bitcoinDataDir,
+            wallet,
             storeInitialized: false,
             storeExists: false,
             indexedTip: null,
             latestCheckpoint: null,
             bootstrap,
+            managedBitcoind,
+            indexer,
+            mining,
             storeError: null,
         };
     }
@@ -77,11 +275,15 @@ export async function inspectPassiveClientStatus(dbPath, bitcoinDataDir) {
         return {
             dbPath,
             bitcoinDataDir,
+            wallet,
             storeInitialized: store.storeInitialized,
             storeExists: true,
             indexedTip: store.indexedTip,
             latestCheckpoint: store.latestCheckpoint,
             bootstrap,
+            managedBitcoind,
+            indexer,
+            mining,
             storeError: null,
         };
     }
@@ -89,12 +291,16 @@ export async function inspectPassiveClientStatus(dbPath, bitcoinDataDir) {
         return {
             dbPath,
             bitcoinDataDir,
+            wallet,
             storeInitialized: false,
             storeExists: true,
             indexedTip: null,
             latestCheckpoint: null,
             bootstrap,
-            storeError: error instanceof Error ? error.message : String(error),
+            managedBitcoind,
+            indexer,
+            mining,
+            storeError: formatUnknownError(error),
         };
     }
 }

package/dist/wallet/lifecycle/repair-bitcoind.js

@@ -18,6 +18,9 @@ export async function repairManagedBitcoindStage(options) {
         error: null,
     };
     let bitcoindPostRepairHealth = "unavailable";
+    const rpcReadyProgress = async (event) => {
+        await reportRepairProgress(options.context, event.code, event.message);
+    };
     const bitcoindLock = await acquireFileLock(options.servicePaths.bitcoindLockPath, {
         purpose: "managed-bitcoind-repair",
         walletRootId: state.walletRootId,
@@ -30,6 +33,7 @@ export async function repairManagedBitcoindStage(options) {
             chain: "main",
             startHeight: 0,
             walletRootId: state.walletRootId,
+            rpcReadyProgress,
         });
         bitcoindCompatibilityIssue = mapBitcoindCompatibilityToRepairIssue(initialBitcoindProbe.compatibility);
         if (initialBitcoindProbe.compatibility === "starting") {
@@ -105,12 +109,12 @@ export async function repairManagedBitcoindStage(options) {
             await reportRepairProgress(options.context, attachAttempt === 0 ? "bitcoind-start" : "bitcoind-retry-start", bitcoindServiceAction === "none"
                 ? "Attaching to managed bitcoind..."
                 : "Starting managed bitcoind with current ZMQ config...");
-            await reportRepairProgress(options.context, "bitcoind-wait-rpc", "Waiting for Bitcoin Core RPC readiness...");
             bitcoindHandle = await options.context.attachService({
                 dataDir: options.context.dataDir,
                 chain: "main",
                 startHeight: 0,
                 walletRootId: state.walletRootId,
+                rpcReadyProgress,
             });
             await reportRepairProgress(options.context, "bitcoind-normalize-wallet", "Checking managed Bitcoin wallet state...");
             const rpc = options.context.rpcFactory(bitcoindHandle.rpc);

package/dist/wallet/mining/competitiveness.js

@@ -673,7 +673,7 @@ export async function runCompetitivenessGate(options) {
         });
         options.throwIfStopping?.();
         const txid = visibleTxids[index];
-        const context = cacheState.rawTxContexts.get(txid);
+        const context = rawTxContexts.get(txid);
         const mempoolEntry = mempoolEntries[txid];
         if (context === undefined || context.payload === null || context.senderScriptHex === null || mempoolEntry === undefined) {
             continue;
@@ -685,7 +685,7 @@ export async function runCompetitivenessGate(options) {
         const overlayDomain = await resolveOverlayAuthorizedMiningDomain({
             readContext: options.readContext,
             txid,
-            txContexts: cacheState.rawTxContexts,
+            txContexts: rawTxContexts,
             domainId: decoded.domainId,
             senderScriptHex: context.senderScriptHex,
         });

package/dist/wallet/mining/mempool-index.js

@@ -2,13 +2,14 @@ import { createHash } from "node:crypto";
 import { mkdir, readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { COG_PREFIX } from "../cogop/constants.js";
-import { writeJsonFileAtomic } from "../fs/atomic.js";
+import { writeFileAtomic } from "../fs/atomic.js";
 import { extractOpReturnPayloadFromScriptHex } from "../tx/register.js";
 const MINING_MEMPOOL_INDEX_SCHEMA_VERSION = 1;
 const MINING_MEMPOOL_INDEX_RAW_TX_FETCH_CONCURRENCY = 8;
 const MINING_MEMPOOL_INDEX_PROGRESS_REPORT_EVERY = 25;
 const indexStates = new Map();
 const rawTxSubscribers = new Map();
+const RAW_TX_SUBSCRIBER_SAVE_DEBOUNCE_MS = 1_000;
 export function resolveMiningMempoolIndexCachePath(paths) {
     return join(paths.miningRoot, "mempool-index.json");
 }
@@ -101,6 +102,8 @@ function getOrCreateState(options) {
         negativeTxids: new Set(),
         loaded: false,
         savePromise: Promise.resolve(),
+        saveScheduled: null,
+        saveDirty: false,
     };
     indexStates.set(key, created);
     return created;
@@ -117,10 +120,30 @@ async function saveState(state) {
     };
     state.savePromise = state.savePromise.catch(() => undefined).then(async () => {
         await mkdir(dirname(state.cachePath), { recursive: true });
-        await writeJsonFileAtomic(state.cachePath, payload, { mode: 0o600 });
+        await writeFileAtomic(state.cachePath, `${JSON.stringify(payload)}\n`, { mode: 0o600 });
     });
     await state.savePromise;
 }
+function scheduleStateSave(state) {
+    state.saveDirty = true;
+    if (state.saveScheduled !== null) {
+        return;
+    }
+    state.saveScheduled = setTimeout(() => {
+        state.saveScheduled = null;
+        if (!state.saveDirty) {
+            return;
+        }
+        state.saveDirty = false;
+        void saveState(state)
+            .catch(() => undefined)
+            .finally(() => {
+            if (state.saveDirty) {
+                scheduleStateSave(state);
+            }
+        });
+    }, RAW_TX_SUBSCRIBER_SAVE_DEBOUNCE_MS);
+}
 function pruneStateToVisibleTxids(state, visibleTxids) {
     const visibleSet = new Set(visibleTxids);
     let changed = false;
@@ -426,8 +449,11 @@ export async function ensureMiningMempoolRawTxSubscriber(options) {
                 if (parsed === null || isCogPayload(parsed.payload)) {
                     continue;
                 }
+                const previousSize = state.negativeTxids.size;
                 state.negativeTxids.add(parsed.txid);
-                void saveState(state).catch(() => undefined);
+                if (state.negativeTxids.size !== previousSize) {
+                    scheduleStateSave(state);
+                }
             }
         }
         catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogcoin/client",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "Store-backed Cogcoin client with wallet flows, SQLite persistence, and managed Bitcoin Core integration.",
   "license": "MIT",
   "type": "module",