@cogcoin/client 1.0.2 → 1.1.0

package/dist/cli/commands/follow.js

@@ -1,83 +1,78 @@
 import { dirname } from "node:path";
-import { FileLockBusyError, acquireFileLock } from "../../wallet/fs/lock.js";
+import { DEFAULT_SNAPSHOT_METADATA, resolveBootstrapPathsForTesting } from "../../bitcoind/bootstrap.js";
 import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolution.js";
+import { followManagedIndexerStatus, ManagedIndexerProgressObserver, } from "../managed-indexer-observer.js";
 import { usesTtyProgress, writeLine } from "../io.js";
-import { classifyCliError, formatCliTextError } from "../output.js";
-import { createStopSignalWatcher } from "../signals.js";
+import { classifyCliError } from "../output.js";
+import { createCloseSignalWatcher, waitForCompletionOrStop } from "../signals.js";
 export async function runFollowCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
     const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+    const packageVersion = await context.readPackageVersion();
     const runtimePaths = context.resolveWalletRuntimePaths();
-    let controlLock = null;
-    let store = null;
-    let storeOwned = true;
+    let monitor = null;
+    let observer = null;
     try {
         const walletRoot = await resolveWalletRootIdFromLocalArtifacts({
             paths: runtimePaths,
             provider: context.walletSecretProvider,
             loadRawWalletStateEnvelope: context.loadRawWalletStateEnvelope,
         });
-        try {
-            controlLock = await acquireFileLock(runtimePaths.walletControlLockPath, {
-                purpose: "managed-follow",
-                walletRootId: walletRoot.walletRootId,
-            });
-        }
-        catch (error) {
-            if (error instanceof FileLockBusyError) {
-                throw new Error("wallet_control_lock_busy");
-            }
-            throw error;
-        }
         await context.ensureDirectory(dirname(dbPath));
-        store = await context.openSqliteStore({ filename: dbPath });
-        const client = await context.openManagedBitcoindClient({
-            store,
-            databasePath: dbPath,
+        monitor = await context.openManagedIndexerMonitor({
             dataDir,
+            databasePath: dbPath,
             walletRootId: walletRoot.walletRootId,
+            expectedBinaryVersion: packageVersion,
+        });
+        observer = new ManagedIndexerProgressObserver({
+            quoteStatePath: resolveBootstrapPathsForTesting(dataDir, DEFAULT_SNAPSHOT_METADATA).quoteStatePath,
+            stream: context.stderr,
             progressOutput: parsed.progressOutput,
+            followVisualMode: true,
+        });
+        const abortController = new AbortController();
+        const stopWatcher = createCloseSignalWatcher({
+            signalSource: context.signalSource,
+            stderr: context.stderr,
+            closeable: {
+                close: async () => {
+                    abortController.abort(new Error("managed_indexer_follow_aborted"));
+                    await observer?.close().catch(() => undefined);
+                    await monitor?.close().catch(() => undefined);
+                },
+            },
+            forceExit: context.forceExit,
+            firstMessage: "Stopping managed Cogcoin tip observation...",
+            successMessage: "Stopped observing managed Cogcoin tip.",
+            failureMessage: "Managed Cogcoin tip observation cleanup failed.",
         });
-        storeOwned = false;
-        const stopWatcher = createStopSignalWatcher(context.signalSource, context.stderr, client, context.forceExit, [runtimePaths.walletControlLockPath]);
         try {
-            await client.startFollowingTip();
             if (!usesTtyProgress(parsed.progressOutput, context.stderr)) {
                 writeLine(context.stdout, "Following managed Cogcoin tip. Press Ctrl-C to stop.");
             }
-            return await stopWatcher.promise;
+            const followOutcome = await waitForCompletionOrStop(followManagedIndexerStatus({
+                monitor,
+                observer,
+                signal: abortController.signal,
+            }), stopWatcher);
+            if (followOutcome.kind === "stopped") {
+                return followOutcome.code;
+            }
+            return 0;
         }
         catch (error) {
             writeLine(context.stderr, `follow failed: ${error instanceof Error ? error.message : String(error)}`);
-            await client.close().catch(() => undefined);
             return classifyCliError(error).exitCode;
         }
         finally {
             stopWatcher.cleanup();
+            await observer?.close().catch(() => undefined);
+            await monitor?.close().catch(() => undefined);
         }
     }
     catch (error) {
-        const classified = classifyCliError(error);
-        if (classified.errorCode === "wallet_control_lock_busy") {
-            const formatted = formatCliTextError(error);
-            if (formatted !== null) {
-                for (const line of formatted) {
-                    writeLine(context.stderr, line);
-                }
-            }
-            else {
-                writeLine(context.stderr, classified.message);
-            }
-        }
-        else {
-            writeLine(context.stderr, `follow failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        if (storeOwned && store !== null) {
-            await store.close().catch(() => undefined);
-        }
-        return classified.exitCode;
-    }
-    finally {
-        await controlLock?.release().catch(() => undefined);
+        writeLine(context.stderr, `follow failed: ${error instanceof Error ? error.message : String(error)}`);
+        return classifyCliError(error).exitCode;
     }
 }

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

@@ -1,9 +1,11 @@
-import { buildMineSetupData, } from "../mining-json.js";
+import { dirname } from "node:path";
+import { buildMinePromptData, buildMineSetupData, } from "../mining-json.js";
 import { buildMineSetupPreviewData } from "../preview-json.js";
+import { formatMiningPromptMutationReport } from "../mining-format.js";
 import { writeLine } from "../io.js";
 import { createTerminalPrompter } from "../prompt.js";
 import { createPreviewSuccessEnvelope, createMutationSuccessEnvelope, describeCanonicalCommand, resolvePreviewJsonSchema, resolveStableMiningControlJsonSchema, writeHandledCliError, writeJsonValue, } from "../output.js";
-import { formatNextStepLines, getMineSetupNextSteps, } from "../workflow-hints.js";
+import { formatNextStepLines, getMineSetupNextSteps } from "../workflow-hints.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 function createCommandPrompter(parsed, context) {
     return parsed.outputMode !== "text"
@@ -13,6 +15,9 @@ function createCommandPrompter(parsed, context) {
 export async function runMiningAdminCommand(parsed, context) {
     try {
         const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
+        const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
+        const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+        const packageVersion = await context.readPackageVersion();
         if (parsed.command === "mine-setup") {
             const prompter = createCommandPrompter(parsed, context);
             const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, prompter);
@@ -50,6 +55,55 @@ export async function runMiningAdminCommand(parsed, context) {
             }
             return 0;
         }
+        if (parsed.command === "mine-prompt") {
+            const prompter = createCommandPrompter(parsed, context);
+            if (!prompter.isInteractive) {
+                throw new Error("mine_prompt_requires_tty");
+            }
+            const provider = withInteractiveWalletSecretProvider(context.walletSecretProvider, prompter);
+            await context.ensureDirectory(dirname(dbPath));
+            const readContext = await context.openWalletReadContext({
+                dataDir,
+                databasePath: dbPath,
+                secretProvider: provider,
+                expectedIndexerBinaryVersion: packageVersion,
+                paths: runtimePaths,
+            });
+            try {
+                const targetDomain = parsed.args[0].trim().toLowerCase();
+                const promptState = await context.inspectMiningDomainPromptState({
+                    paths: runtimePaths,
+                    provider,
+                    readContext,
+                });
+                const currentEntry = promptState.prompts.find((entry) => entry.domain.name === targetDomain);
+                if (currentEntry === undefined) {
+                    throw new Error("mine_prompt_domain_not_mineable");
+                }
+                if (parsed.outputMode === "text") {
+                    writeLine(context.stdout, `Domain: ${currentEntry.domain.name}`);
+                    writeLine(context.stdout, `Current domain prompt: ${currentEntry.prompt ?? "none"}`);
+                    writeLine(context.stdout, `Global fallback prompt: ${promptState.fallbackPromptConfigured ? "configured" : "not configured"}`);
+                }
+                const nextPrompt = await prompter.prompt("Domain prompt (blank to clear and use the global fallback): ");
+                const result = await context.updateMiningDomainPrompt({
+                    paths: runtimePaths,
+                    provider,
+                    readContext,
+                    domainName: targetDomain,
+                    prompt: nextPrompt,
+                });
+                if (parsed.outputMode === "json") {
+                    writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMiningControlJsonSchema(parsed), describeCanonicalCommand(parsed), result.status, buildMinePromptData(result)));
+                    return 0;
+                }
+                writeLine(context.stdout, formatMiningPromptMutationReport(result));
+                return 0;
+            }
+            finally {
+                await readContext.close();
+            }
+        }
         writeLine(context.stderr, `mining admin command not implemented: ${parsed.command}`);
         return 1;
     }

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

@@ -1,9 +1,10 @@
 import { dirname } from "node:path";
 import { stat } from "node:fs/promises";
-import { formatMineStatusReport, formatMiningEventRecord } from "../mining-format.js";
+import { formatMineStatusReport, formatMiningEventRecord, formatMiningPromptListReport, } from "../mining-format.js";
 import { writeLine } from "../io.js";
 import { createErrorEnvelope, createSuccessEnvelope, describeCanonicalCommand, normalizeListPage, writeJsonValue, } from "../output.js";
-import { buildMineLogJson, buildMineStatusJson } from "../read-json.js";
+import { buildMineLogJson, buildMinePromptListJson, buildMineStatusJson } from "../read-json.js";
+import { formatNextStepLines } from "../workflow-hints.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 async function readRotationIndices(paths) {
     const rotation = [];
@@ -24,6 +25,7 @@ export async function runMiningReadCommand(parsed, context) {
     try {
         const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
         const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+        const packageVersion = await context.readPackageVersion();
         const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
         await context.ensureDirectory(dirname(dbPath));
         if (parsed.command === "mine-log") {
@@ -88,6 +90,41 @@ export async function runMiningReadCommand(parsed, context) {
             }
             return 0;
         }
+        if (parsed.command === "mine-prompt-list") {
+            const provider = parsed.outputMode === "text"
+                ? withInteractiveWalletSecretProvider(context.walletSecretProvider, context.createPrompter())
+                : context.walletSecretProvider;
+            const readContext = await context.openWalletReadContext({
+                dataDir,
+                databasePath: dbPath,
+                secretProvider: provider,
+                expectedIndexerBinaryVersion: packageVersion,
+                paths: runtimePaths,
+            });
+            try {
+                const result = buildMinePromptListJson(await context.inspectMiningDomainPromptState({
+                    paths: runtimePaths,
+                    provider,
+                    readContext,
+                }));
+                if (parsed.outputMode === "json") {
+                    writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/mine-prompt-list/v1", describeCanonicalCommand(parsed), result.data, {
+                        warnings: result.warnings,
+                        explanations: result.explanations,
+                        nextSteps: result.nextSteps,
+                    }));
+                    return 0;
+                }
+                writeLine(context.stdout, formatMiningPromptListReport(result.data));
+                for (const line of formatNextStepLines(result.nextSteps)) {
+                    writeLine(context.stdout, line);
+                }
+                return 0;
+            }
+            finally {
+                await readContext.close();
+            }
+        }
         const provider = parsed.outputMode === "text"
             ? withInteractiveWalletSecretProvider(context.walletSecretProvider, context.createPrompter())
             : context.walletSecretProvider;
@@ -95,6 +132,7 @@ export async function runMiningReadCommand(parsed, context) {
             dataDir,
             databasePath: dbPath,
             secretProvider: provider,
+            expectedIndexerBinaryVersion: packageVersion,
             paths: runtimePaths,
         });
         try {
@@ -128,7 +166,9 @@ export async function runMiningReadCommand(parsed, context) {
         if (parsed.outputMode === "json") {
             writeJsonValue(context.stdout, createErrorEnvelope(parsed.command === "mine-log"
                 ? "cogcoin/mine-log/v1"
-                : "cogcoin/mine-status/v1", describeCanonicalCommand(parsed), message, message));
+                : parsed.command === "mine-prompt-list"
+                    ? "cogcoin/mine-prompt-list/v1"
+                    : "cogcoin/mine-status/v1", describeCanonicalCommand(parsed), message, message));
             return 5;
         }
         writeLine(context.stderr, message);

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

@@ -1,15 +1,17 @@
 import { dirname } from "node:path";
-import { FileLockBusyError, acquireFileLock } from "../../wallet/fs/lock.js";
+import { DEFAULT_SNAPSHOT_METADATA, resolveBootstrapPathsForTesting } from "../../bitcoind/bootstrap.js";
 import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolution.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
+import { ManagedIndexerProgressObserver, pollManagedIndexerUntilCaughtUp, } from "../managed-indexer-observer.js";
 import { buildMineStartData, buildMineStopData, } from "../mining-json.js";
 import { buildMineStartPreviewData, buildMineStopPreviewData, } from "../preview-json.js";
 import { usesTtyProgress, writeLine } from "../io.js";
 import { createTerminalPrompter } from "../prompt.js";
 import { createPreviewSuccessEnvelope, createMutationSuccessEnvelope, describeCanonicalCommand, resolvePreviewJsonSchema, resolveStableMiningControlJsonSchema, writeHandledCliError, writeJsonValue, } from "../output.js";
 import { formatNextStepLines, getMineStopNextSteps, } from "../workflow-hints.js";
-import { createStopSignalWatcher, waitForCompletionOrStop } from "../signals.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";
 function createCommandPrompter(parsed, context) {
     return parsed.outputMode !== "text"
         ? createTerminalPrompter(context.stdin, context.stderr)
@@ -27,89 +29,98 @@ async function ensureMiningProviderSetup(options) {
 }
 async function syncManagedMiningReadiness(options) {
     const ttyProgressActive = usesTtyProgress(options.parsed.progressOutput, options.context.stderr);
-    let controlLock = null;
-    let store = null;
-    let storeOwned = true;
-    let client = null;
-    let clientClosed = false;
+    let monitor = null;
+    let observer = null;
+    const walletRoot = await resolveWalletRootIdFromLocalArtifacts({
+        paths: options.runtimePaths,
+        provider: options.provider,
+        loadRawWalletStateEnvelope: options.context.loadRawWalletStateEnvelope,
+    });
+    await options.context.ensureDirectory(dirname(options.databasePath));
+    monitor = await options.context.openManagedIndexerMonitor({
+        dataDir: options.dataDir,
+        databasePath: options.databasePath,
+        walletRootId: walletRoot.walletRootId,
+        expectedBinaryVersion: options.expectedBinaryVersion,
+    });
+    observer = new ManagedIndexerProgressObserver({
+        quoteStatePath: resolveBootstrapPathsForTesting(options.dataDir, DEFAULT_SNAPSHOT_METADATA).quoteStatePath,
+        stream: options.context.stderr,
+        progressOutput: options.parsed.progressOutput,
+        onProgress: ttyProgressActive ? undefined : createSyncProgressReporter({
+            progressOutput: options.parsed.progressOutput,
+            write: (line) => {
+                writeLine(options.context.stderr, line);
+            },
+        }),
+    });
+    const abortController = new AbortController();
+    const stopWatcher = createCloseSignalWatcher({
+        signalSource: options.context.signalSource,
+        stderr: options.context.stderr,
+        closeable: {
+            close: async () => {
+                abortController.abort(new Error("managed_indexer_preflight_aborted"));
+                await observer?.close().catch(() => undefined);
+                await monitor?.close().catch(() => undefined);
+            },
+        },
+        forceExit: options.context.forceExit,
+        firstMessage: "Stopping managed mining readiness observation...",
+        successMessage: "Stopped observing managed mining readiness.",
+        failureMessage: "Managed mining readiness observation cleanup failed.",
+    });
     try {
-        const walletRoot = await resolveWalletRootIdFromLocalArtifacts({
-            paths: options.runtimePaths,
-            provider: options.provider,
-            loadRawWalletStateEnvelope: options.context.loadRawWalletStateEnvelope,
-        });
-        try {
-            controlLock = await acquireFileLock(options.runtimePaths.walletControlLockPath, {
-                purpose: "managed-sync",
-                walletRootId: walletRoot.walletRootId,
-            });
+        const syncOutcome = await waitForCompletionOrStop(pollManagedIndexerUntilCaughtUp({
+            monitor,
+            observer,
+            signal: abortController.signal,
+        }), stopWatcher);
+        if (syncOutcome.kind === "stopped") {
+            return syncOutcome.code;
         }
-        catch (error) {
-            if (error instanceof FileLockBusyError) {
-                throw new Error("wallet_control_lock_busy");
-            }
-            throw error;
+        return null;
+    }
+    finally {
+        stopWatcher.cleanup();
+        await observer?.close().catch(() => undefined);
+        await monitor?.close().catch(() => undefined);
+    }
+}
+async function resolveMineUpdateAvailable(currentVersion, context) {
+    if (isUpdateCheckDisabled(context.env)) {
+        return false;
+    }
+    try {
+        const cachePath = context.resolveUpdateCheckStatePath();
+        const now = context.now();
+        let cache = await loadUpdateCheckCache(cachePath) ?? createEmptyUpdateCheckCache();
+        let cacheChanged = false;
+        if (shouldRefreshUpdateCheck(cache, now)) {
+            const updateResult = await fetchLatestPublishedVersion(context.fetchImpl, {
+                timeoutMs: PASSIVE_UPDATE_CHECK_TIMEOUT_MS,
+            });
+            cache = applyUpdateCheckResult(cache, updateResult, now);
+            cacheChanged = true;
         }
-        await options.context.ensureDirectory(dirname(options.databasePath));
-        store = await options.context.openSqliteStore({ filename: options.databasePath });
-        client = await options.context.openManagedBitcoindClient({
-            store,
-            databasePath: options.databasePath,
-            dataDir: options.dataDir,
-            walletRootId: walletRoot.walletRootId,
-            progressOutput: options.parsed.progressOutput,
-            onProgress: ttyProgressActive ? undefined : createSyncProgressReporter({
-                progressOutput: options.parsed.progressOutput,
-                write: (line) => {
-                    writeLine(options.context.stderr, line);
-                },
-            }),
-        });
-        storeOwned = false;
-        const stopWatcher = createStopSignalWatcher(options.context.signalSource, options.context.stderr, client, options.context.forceExit, [options.runtimePaths.walletControlLockPath]);
-        try {
-            const syncOutcome = await waitForCompletionOrStop(client.syncToTip(), stopWatcher);
-            if (syncOutcome.kind === "stopped") {
-                return syncOutcome.code;
-            }
-            const result = syncOutcome.value;
-            if (result.endingHeight !== null && result.endingHeight === result.bestHeight) {
-                stopWatcher.cleanup();
-                const detachPromise = typeof client.detachToBackgroundFollow === "function"
-                    ? client.detachToBackgroundFollow()
-                    : Promise.resolve();
-                try {
-                    await detachPromise;
-                    await client.close();
-                    clientClosed = true;
-                    writeLine(options.context.stderr, "Detached cleanly; background indexer follow resumed.");
-                    return null;
-                }
-                catch {
-                    writeLine(options.context.stderr, "Detach failed before background indexer follow was confirmed.");
-                    return 1;
-                }
-            }
-            throw new Error("Managed sync did not reach the current Bitcoin tip.");
+        if (cacheChanged) {
+            await persistUpdateCheckCache(cachePath, cache);
         }
-        finally {
-            stopWatcher.cleanup();
-            if (!clientClosed) {
-                await client.close();
-            }
+        if (cache.latestVersion === null) {
+            return false;
         }
+        const comparison = compareSemver(cache.latestVersion, currentVersion);
+        return comparison !== null && comparison > 0;
     }
-    finally {
-        if (storeOwned && store !== null) {
-            await store.close().catch(() => undefined);
-        }
-        await controlLock?.release().catch(() => undefined);
+    catch {
+        return false;
     }
 }
 export async function runMiningRuntimeCommand(parsed, context) {
     try {
         const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
         const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+        const packageVersion = await context.readPackageVersion();
         const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
         if (parsed.command === "mine") {
             const prompter = context.createPrompter();
@@ -125,12 +136,16 @@ export async function runMiningRuntimeCommand(parsed, context) {
                 context,
                 dataDir,
                 databasePath: dbPath,
+                expectedBinaryVersion: packageVersion,
                 provider,
                 runtimePaths,
             });
             if (preflightCode !== null) {
                 return preflightCode;
             }
+            const updateAvailable = usesTtyProgress(parsed.progressOutput, context.stderr)
+                ? await resolveMineUpdateAvailable(packageVersion, context)
+                : false;
             const abortController = new AbortController();
             const onStop = () => {
                 abortController.abort();
@@ -139,6 +154,8 @@ export async function runMiningRuntimeCommand(parsed, context) {
             context.signalSource.on("SIGTERM", onStop);
             try {
                 await context.runForegroundMining({
+                    clientVersion: packageVersion,
+                    updateAvailable,
                     dataDir,
                     databasePath: dbPath,
                     provider,
@@ -171,6 +188,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
                 context,
                 dataDir,
                 databasePath: dbPath,
+                expectedBinaryVersion: packageVersion,
                 provider,
                 runtimePaths,
             });

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

@@ -2,6 +2,7 @@ import { dirname } from "node:path";
 import { loadBundledGenesisParameters } from "@cogcoin/indexer";
 import { resolveCogcoinProcessingStartHeight } from "../../bitcoind/processing-start-height.js";
 import { UNINITIALIZED_WALLET_ROOT_ID, resolveManagedServicePaths } from "../../bitcoind/service-paths.js";
+import { INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED, } from "../../bitcoind/indexer-daemon.js";
 import { resolveWalletRootIdFromLocalArtifacts, } from "../../wallet/root-resolution.js";
 import { writeLine } from "../io.js";
 import { createSuccessEnvelope, describeCanonicalCommand, writeHandledCliError, writeJsonValue, } from "../output.js";
@@ -86,13 +87,49 @@ async function inspectManagedBitcoindStatus(dataDir, context) {
         nodeError,
     };
 }
-async function inspectManagedIndexerStatus(dataDir, context) {
+async function inspectManagedIndexerStatus(dataDir, databasePath, expectedBinaryVersion, context) {
     const resolution = await resolveEffectiveWalletRootId(context);
     const runtimeRoot = resolveManagedServicePaths(dataDir, resolution.walletRootId).walletRuntimeRoot;
     const probe = await context.probeIndexerDaemon({
         dataDir,
         walletRootId: resolution.walletRootId,
     });
+    await probe.client?.close().catch(() => undefined);
+    if (probe.compatibility === "compatible" || probe.compatibility === "unreachable") {
+        try {
+            const daemonClient = await context.attachIndexerDaemon({
+                dataDir,
+                databasePath,
+                walletRootId: resolution.walletRootId,
+                ensureBackgroundFollow: true,
+                expectedBinaryVersion,
+            });
+            try {
+                const daemon = await daemonClient.getStatus();
+                return {
+                    dataDir,
+                    walletRootId: resolution.walletRootId,
+                    walletRootSource: resolution.source,
+                    compatibility: "compatible",
+                    source: "probe",
+                    daemon: {
+                        ...daemon,
+                        runtimeRoot,
+                    },
+                };
+            }
+            finally {
+                await daemonClient.close().catch(() => undefined);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error
+                && error.message === INDEXER_DAEMON_BACKGROUND_FOLLOW_RECOVERY_FAILED) {
+                throw error;
+            }
+            // Preserve the status-file fallback when the refresh path fails.
+        }
+    }
     let source = "probe";
     let daemon = probe.status;
     if (probe.compatibility === "unreachable") {
@@ -291,7 +328,10 @@ export async function runServiceRuntimeCommand(parsed, context) {
             return 0;
         }
         if (parsed.command === "indexer-status") {
-            const payload = await inspectManagedIndexerStatus(dataDir, context);
+            const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
+            const packageVersion = await context.readPackageVersion();
+            await context.ensureDirectory(dirname(dbPath));
+            const payload = await inspectManagedIndexerStatus(dataDir, dbPath, packageVersion, context);
             const messages = buildStatusMessages(payload);
             if (parsed.outputMode === "json") {
                 writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/indexer-status/v1", describeCanonicalCommand(parsed), payload, messages));

package/dist/cli/commands/status.js

@@ -8,6 +8,7 @@ import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider
 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(parsed.seedName);
     await context.ensureDirectory(dirname(dbPath));
     const provider = parsed.outputMode === "text"
@@ -17,6 +18,7 @@ export async function runStatusCommand(parsed, context) {
         dataDir,
         databasePath: dbPath,
         secretProvider: provider,
+        expectedIndexerBinaryVersion: packageVersion,
         paths: runtimePaths,
     });
     try {
@@ -29,7 +31,7 @@ export async function runStatusCommand(parsed, context) {
             }));
             return 0;
         }
-        writeLine(context.stdout, formatWalletOverviewReport(readContext, await context.readPackageVersion()));
+        writeLine(context.stdout, formatWalletOverviewReport(readContext, packageVersion));
         writeLine(context.stdout, formatBalanceReport(readContext));
         return 0;
     }