@cogcoin/client 0.5.5 → 0.5.7

package/dist/cli/commands/follow.js

@@ -1,10 +1,19 @@
 import { dirname } from "node:path";
+import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolution.js";
 import { usesTtyProgress, writeLine } from "../io.js";
 import { classifyCliError } from "../output.js";
 import { createStopSignalWatcher } from "../signals.js";
+import { confirmGetblockArchiveRestart } from "./getblock-archive-restart.js";
 export async function runFollowCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
     const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+    const walletRoot = await resolveWalletRootIdFromLocalArtifacts({
+        paths: context.resolveWalletRuntimePaths(),
+        provider: context.walletSecretProvider,
+        loadRawWalletStateEnvelope: context.loadRawWalletStateEnvelope,
+        loadUnlockSession: context.loadUnlockSession,
+        loadWalletExplicitLock: context.loadWalletExplicitLock,
+    });
     await context.ensureDirectory(dirname(dbPath));
     const store = await context.openSqliteStore({ filename: dbPath });
     let storeOwned = true;
@@ -13,7 +22,9 @@ export async function runFollowCommand(parsed, context) {
             store,
             databasePath: dbPath,
             dataDir,
+            walletRootId: walletRoot.walletRootId,
             progressOutput: parsed.progressOutput,
+            confirmGetblockArchiveRestart: async (options) => confirmGetblockArchiveRestart(parsed, context, options),
         });
         storeOwned = false;
         const stopWatcher = createStopSignalWatcher(context.signalSource, context.stderr, client, context.forceExit);

package/dist/cli/commands/getblock-archive-restart.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedCliArgs, RequiredCliRunnerContext } from "../types.js";
+export declare function confirmGetblockArchiveRestart(parsed: ParsedCliArgs, context: RequiredCliRunnerContext, options: {
+    currentArchiveEndHeight: number | null;
+    nextArchiveEndHeight: number;
+}): Promise<boolean>;

package/dist/cli/commands/getblock-archive-restart.js

@@ -0,0 +1,15 @@
+export async function confirmGetblockArchiveRestart(parsed, context, options) {
+    if (parsed.assumeYes) {
+        return true;
+    }
+    const prompter = context.createPrompter();
+    if (!prompter.isInteractive) {
+        return false;
+    }
+    const currentLabel = options.currentArchiveEndHeight === null
+        ? "without a getblock archive"
+        : `with a getblock archive through height ${options.currentArchiveEndHeight.toLocaleString()}`;
+    prompter.writeLine(`Managed bitcoind is already running ${currentLabel}. A newer getblock archive through height ${options.nextArchiveEndHeight.toLocaleString()} is available.`);
+    const answer = (await prompter.prompt(`Restart managed bitcoind to load the getblock archive through height ${options.nextArchiveEndHeight.toLocaleString()}? [y/N]: `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+}

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

@@ -12,11 +12,13 @@ function createCommandPrompter(parsed, context) {
 export async function runMiningAdminCommand(parsed, context) {
     try {
         const provider = context.walletSecretProvider;
+        const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
         if (parsed.command === "hooks-mining-enable") {
             const prompter = createCommandPrompter(parsed, context);
             const view = await context.enableMiningHooks({
                 provider,
                 prompter,
+                paths: runtimePaths,
             });
             const nextSteps = getHooksEnableMiningNextSteps();
             if (parsed.outputMode === "preview-json") {
@@ -40,6 +42,7 @@ export async function runMiningAdminCommand(parsed, context) {
         if (parsed.command === "hooks-mining-disable") {
             const view = await context.disableMiningHooks({
                 provider,
+                paths: runtimePaths,
             });
             if (parsed.outputMode === "preview-json") {
                 writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), "disabled", buildHooksPreviewData("hooks-disable-mining", view)));
@@ -57,6 +60,7 @@ export async function runMiningAdminCommand(parsed, context) {
             const view = await context.setupBuiltInMining({
                 provider,
                 prompter,
+                paths: runtimePaths,
             });
             const nextSteps = getMineSetupNextSteps();
             if (parsed.outputMode === "preview-json") {

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

@@ -5,9 +5,7 @@ import { writeLine } from "../io.js";
 import { inspectWalletLocalState } from "../../wallet/read/index.js";
 import { createErrorEnvelope, createSuccessEnvelope, describeCanonicalCommand, normalizeListPage, writeJsonValue, } from "../output.js";
 import { buildHooksStatusJson, buildMineLogJson, buildMineStatusJson } from "../read-json.js";
-import { resolveWalletRuntimePathsForTesting } from "../../wallet/runtime.js";
-async function readRotationIndices() {
-    const paths = resolveWalletRuntimePathsForTesting();
+async function readRotationIndices(paths) {
     const rotation = [];
     for (let index = 1; index <= 4; index += 1) {
         try {
@@ -26,10 +24,12 @@ export async function runMiningReadCommand(parsed, context) {
     try {
         const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
         const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+        const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
         await context.ensureDirectory(dirname(dbPath));
         if (parsed.command === "hooks-mining-status") {
             const localState = await inspectWalletLocalState({
                 secretProvider: context.walletSecretProvider,
+                paths: runtimePaths,
             });
             const view = await context.inspectMiningControlPlane({
                 provider: context.walletSecretProvider,
@@ -52,6 +52,7 @@ export async function runMiningReadCommand(parsed, context) {
                     openedAtUnixMs: null,
                 },
                 verify: parsed.verify,
+                paths: runtimePaths,
             });
             if (parsed.outputMode === "json") {
                 const result = buildHooksStatusJson(view);
@@ -79,7 +80,7 @@ export async function runMiningReadCommand(parsed, context) {
                 const events = normalized.items.slice().reverse();
                 if (events.length === 0) {
                     if (parsed.outputMode === "json") {
-                        const result = buildMineLogJson(events, normalized.page, await readRotationIndices());
+                        const result = buildMineLogJson(events, normalized.page, await readRotationIndices(runtimePaths));
                         writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/mine-log/v1", describeCanonicalCommand(parsed), result.data, {
                             warnings: result.warnings,
                             explanations: result.explanations,
@@ -91,7 +92,7 @@ export async function runMiningReadCommand(parsed, context) {
                     return 0;
                 }
                 if (parsed.outputMode === "json") {
-                    const result = buildMineLogJson(events, normalized.page, await readRotationIndices());
+                    const result = buildMineLogJson(events, normalized.page, await readRotationIndices(runtimePaths));
                     writeJsonValue(context.stdout, createSuccessEnvelope("cogcoin/mine-log/v1", describeCanonicalCommand(parsed), result.data, {
                         warnings: result.warnings,
                         explanations: result.explanations,
@@ -131,6 +132,7 @@ export async function runMiningReadCommand(parsed, context) {
             dataDir,
             databasePath: dbPath,
             secretProvider: context.walletSecretProvider,
+            paths: runtimePaths,
         });
         try {
             const mining = readContext.mining ?? await context.inspectMiningControlPlane({
@@ -140,6 +142,7 @@ export async function runMiningReadCommand(parsed, context) {
                 nodeStatus: readContext.nodeStatus,
                 nodeHealth: readContext.nodeHealth,
                 indexer: readContext.indexer,
+                paths: runtimePaths,
             });
             if (parsed.outputMode === "json") {
                 const result = buildMineStatusJson(mining);

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

@@ -15,6 +15,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
         const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
         const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
         const provider = context.walletSecretProvider;
+        const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
         await context.ensureDirectory(dirname(dbPath));
         if (parsed.command === "mine") {
             const abortController = new AbortController();
@@ -33,6 +34,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
                     stdout: context.stdout,
                     stderr: context.stderr,
                     progressOutput: parsed.progressOutput,
+                    paths: runtimePaths,
                 });
             }
             finally {
@@ -47,6 +49,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
                 databasePath: dbPath,
                 provider,
                 prompter: createCommandPrompter(parsed, context),
+                paths: runtimePaths,
             });
             if (parsed.outputMode === "preview-json") {
                 writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), result.started ? "started" : "already-active", buildMineStartPreviewData(result)));
@@ -74,6 +77,7 @@ export async function runMiningRuntimeCommand(parsed, context) {
                 dataDir,
                 databasePath: dbPath,
                 provider,
+                paths: runtimePaths,
             });
             const nextSteps = getMineStopNextSteps();
             if (parsed.outputMode === "preview-json") {

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

@@ -1,6 +1,8 @@
 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 { resolveWalletRootIdFromLocalArtifacts, } from "../../wallet/root-resolution.js";
 import { writeLine } from "../io.js";
 import { createSuccessEnvelope, describeCanonicalCommand, writeHandledCliError, writeJsonValue, } from "../output.js";
 function formatBool(value) {
@@ -12,66 +14,39 @@ function formatMaybe(value) {
 function formatCompatibility(value) {
     return value.replaceAll("-", " ");
 }
-async function resolveEffectiveWalletRootId(dataDir, context) {
-    const paths = context.resolveWalletRuntimePaths();
-    try {
-        const loaded = await context.loadWalletState({
-            primaryPath: paths.walletStatePath,
-            backupPath: paths.walletStateBackupPath,
-        }, {
-            provider: context.walletSecretProvider,
-        });
-        return {
-            walletRootId: loaded.state.walletRootId,
-            source: "wallet-state",
-        };
-    }
-    catch {
-        // fall through
-    }
-    try {
-        const unlockSession = await context.loadUnlockSession(paths.walletUnlockSessionPath, {
-            provider: context.walletSecretProvider,
-        });
-        return {
-            walletRootId: unlockSession.walletRootId,
-            source: "unlock-session",
-        };
-    }
-    catch {
-        // fall through
-    }
-    try {
-        const explicitLock = await context.loadWalletExplicitLock(paths.walletExplicitLockPath);
-        if (explicitLock?.walletRootId) {
-            return {
-                walletRootId: explicitLock.walletRootId,
-                source: "explicit-lock",
-            };
-        }
-    }
-    catch {
-        // fall through
-    }
-    const fallbackProbe = await context.probeManagedBitcoindService({
-        dataDir,
-        chain: "main",
-        startHeight: 0,
-        walletRootId: UNINITIALIZED_WALLET_ROOT_ID,
-    });
-    if (fallbackProbe.status?.walletRootId) {
-        return {
-            walletRootId: fallbackProbe.status.walletRootId,
-            source: "bitcoind-status",
-        };
-    }
+function serviceStatusEntry(label, value, ok) {
     return {
+        text: `${label}: ${value}`,
+        ok,
+    };
+}
+function formatServiceStatusSection(header, entries) {
+    return [header, ...entries.map((entry) => `${entry.ok ? "✓" : "✗"} ${entry.text}`)].join("\n");
+}
+function formatSectionedServiceStatusReport(options) {
+    const parts = [
+        `\n⛭ ${options.title} ⛭`,
+        ...options.sections.map((section) => formatServiceStatusSection(section.header, section.entries)),
+    ];
+    if (options.nextStep !== null) {
+        parts.push(`Next step: ${options.nextStep}`);
+    }
+    return parts.join("\n\n");
+}
+async function resolveEffectiveWalletRootId(context) {
+    return resolveWalletRootIdFromLocalArtifacts({
+        paths: context.resolveWalletRuntimePaths(),
+        provider: context.walletSecretProvider,
+        loadRawWalletStateEnvelope: context.loadRawWalletStateEnvelope,
+        loadUnlockSession: context.loadUnlockSession,
+        loadWalletExplicitLock: context.loadWalletExplicitLock,
+    }).catch(() => ({
         walletRootId: UNINITIALIZED_WALLET_ROOT_ID,
         source: "default-uninitialized",
-    };
+    }));
 }
 async function inspectManagedBitcoindStatus(dataDir, context) {
-    const resolution = await resolveEffectiveWalletRootId(dataDir, context);
+    const resolution = await resolveEffectiveWalletRootId(context);
     const probe = await context.probeManagedBitcoindService({
         dataDir,
         chain: "main",
@@ -114,7 +89,7 @@ async function inspectManagedBitcoindStatus(dataDir, context) {
     };
 }
 async function inspectManagedIndexerStatus(dataDir, context) {
-    const resolution = await resolveEffectiveWalletRootId(dataDir, context);
+    const resolution = await resolveEffectiveWalletRootId(context);
     const runtimeRoot = resolveManagedServicePaths(dataDir, resolution.walletRootId).walletRuntimeRoot;
     const probe = await context.probeIndexerDaemon({
         dataDir,
@@ -144,96 +119,137 @@ async function inspectManagedIndexerStatus(dataDir, context) {
     };
 }
 function formatBitcoinStatusReport(payload) {
-    const lines = [
-        "Managed Bitcoind Status",
-        `Bitcoin datadir: ${payload.dataDir}`,
-        `Wallet root: ${payload.walletRootId}`,
-        `Wallet root source: ${payload.walletRootSource}`,
-        `Compatibility: ${formatCompatibility(payload.compatibility)}`,
+    const compatibilityOk = payload.compatibility === "compatible";
+    const serviceStateOk = payload.service?.state === "ready";
+    const nodeOk = payload.node !== null && payload.nodeError === null;
+    const managedServiceEntries = [
+        serviceStatusEntry("Compatibility", formatCompatibility(payload.compatibility), compatibilityOk),
     ];
     if (payload.service !== null) {
-        lines.push(`Service state: ${payload.service.state}`);
-        lines.push(`Process id: ${formatMaybe(payload.service.processId)}`);
-        lines.push(`Service instance: ${payload.service.serviceInstanceId}`);
-        lines.push(`Runtime root: ${payload.service.runtimeRoot}`);
-        lines.push(`Chain: ${payload.service.chain}`);
-        lines.push(`RPC: ${payload.service.rpc.url}`);
-        lines.push(`RPC cookie: ${payload.service.rpc.cookieFile}`);
-        lines.push(`ZMQ: ${payload.service.zmq.endpoint}`);
-        lines.push(`P2P port: ${payload.service.p2pPort}`);
-        lines.push(`Started at: ${payload.service.startedAtUnixMs}`);
-        lines.push(`Heartbeat at: ${payload.service.heartbeatAtUnixMs}`);
-        lines.push(`Updated at: ${payload.service.updatedAtUnixMs}`);
-        lines.push(`Managed Core wallet: ${payload.service.walletReplica?.proofStatus ?? "unavailable"}`);
+        managedServiceEntries.push(serviceStatusEntry("Service state", payload.service.state, serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Process id", formatMaybe(payload.service.processId), serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Service instance", payload.service.serviceInstanceId, serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Runtime root", payload.service.runtimeRoot, serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Chain", payload.service.chain, serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("RPC", payload.service.rpc.url, serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("RPC cookie", payload.service.rpc.cookieFile, serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("ZMQ", payload.service.zmq.endpoint, serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("P2P port", String(payload.service.p2pPort), serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Started at", String(payload.service.startedAtUnixMs), serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Heartbeat at", String(payload.service.heartbeatAtUnixMs), serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Updated at", String(payload.service.updatedAtUnixMs), serviceStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Managed Core wallet", payload.service.walletReplica?.proofStatus ?? "unavailable", payload.service.walletReplica?.proofStatus === "ready"));
         if (payload.service.lastError !== null) {
-            lines.push(`Service error: ${payload.service.lastError}`);
+            managedServiceEntries.push(serviceStatusEntry("Service error", payload.service.lastError, false));
         }
     }
     else {
-        lines.push("Service state: unavailable");
-    }
-    if (payload.node !== null) {
-        lines.push(`Bitcoin best height: ${payload.node.bestHeight}`);
-        lines.push(`Bitcoin headers: ${payload.node.headerHeight}`);
-        lines.push(`Bitcoin best hash: ${payload.node.bestHash}`);
-        lines.push(`Verification progress: ${formatMaybe(payload.node.verificationProgress)}`);
-        lines.push(`Initial block download: ${formatBool(payload.node.initialBlockDownload)}`);
-        lines.push(`Network active: ${formatBool(payload.node.networkActive)}`);
-        lines.push(`Connections: ${payload.node.connections}`);
-        lines.push(`Inbound connections: ${formatMaybe(payload.node.inboundConnections)}`);
-        lines.push(`Outbound connections: ${formatMaybe(payload.node.outboundConnections)}`);
-    }
-    else {
-        lines.push("Bitcoin node: unavailable");
+        managedServiceEntries.push(serviceStatusEntry("Service state", "unavailable", false));
     }
+    const bitcoinNodeEntries = payload.node !== null
+        ? [
+            serviceStatusEntry("Best height", String(payload.node.bestHeight), nodeOk),
+            serviceStatusEntry("Headers", String(payload.node.headerHeight), nodeOk),
+            serviceStatusEntry("Best hash", payload.node.bestHash, nodeOk),
+            serviceStatusEntry("Verification progress", formatMaybe(payload.node.verificationProgress), nodeOk),
+            serviceStatusEntry("Initial block download", formatBool(payload.node.initialBlockDownload), nodeOk),
+            serviceStatusEntry("Network active", formatBool(payload.node.networkActive), nodeOk),
+            serviceStatusEntry("Connections", String(payload.node.connections), nodeOk),
+            serviceStatusEntry("Inbound connections", formatMaybe(payload.node.inboundConnections), nodeOk),
+            serviceStatusEntry("Outbound connections", formatMaybe(payload.node.outboundConnections), nodeOk),
+        ]
+        : [serviceStatusEntry("Node state", "unavailable", false)];
     if (payload.nodeError !== null) {
-        lines.push(`Node error: ${payload.nodeError}`);
-    }
-    if (payload.compatibility === "unreachable") {
-        lines.push("Recommended next step: Run `cogcoin bitcoin start` to start the managed Bitcoin service.");
+        bitcoinNodeEntries.push(serviceStatusEntry("Node error", payload.nodeError, false));
     }
-    return `${lines.join("\n")}\n`;
+    return formatSectionedServiceStatusReport({
+        title: "Bitcoin Status",
+        sections: [
+            {
+                header: "Paths",
+                entries: [
+                    serviceStatusEntry("Bitcoin datadir", payload.dataDir, true),
+                    serviceStatusEntry("Wallet root", payload.walletRootId, true),
+                    serviceStatusEntry("Wallet root source", payload.walletRootSource, true),
+                ],
+            },
+            {
+                header: "Managed Service",
+                entries: managedServiceEntries,
+            },
+            {
+                header: "Bitcoin Node",
+                entries: bitcoinNodeEntries,
+            },
+        ],
+        nextStep: payload.compatibility === "unreachable"
+            ? "Run `cogcoin bitcoin start` to start the managed Bitcoin service."
+            : null,
+    });
 }
 function formatIndexerStatusReport(payload) {
-    const lines = [
-        "Managed Indexer Status",
-        `Bitcoin datadir: ${payload.dataDir}`,
-        `Wallet root: ${payload.walletRootId}`,
-        `Wallet root source: ${payload.walletRootSource}`,
-        `Compatibility: ${formatCompatibility(payload.compatibility)}`,
-        `Observed source: ${payload.source}`,
+    const compatibilityOk = payload.compatibility === "compatible";
+    const observedSourceOk = payload.source === "probe";
+    const daemonStateOk = payload.daemon?.state === "synced";
+    const managedServiceEntries = [
+        serviceStatusEntry("Compatibility", formatCompatibility(payload.compatibility), compatibilityOk),
+        serviceStatusEntry("Observed source", payload.source, observedSourceOk),
     ];
     if (payload.daemon !== null) {
-        lines.push(`Daemon state: ${payload.daemon.state}`);
-        lines.push(`Process id: ${formatMaybe(payload.daemon.processId)}`);
-        lines.push(`Daemon instance: ${payload.daemon.daemonInstanceId}`);
-        lines.push(`Runtime root: ${payload.daemon.runtimeRoot}`);
-        lines.push(`Schema version: ${payload.daemon.schemaVersion}`);
-        lines.push(`Started at: ${payload.daemon.startedAtUnixMs}`);
-        lines.push(`Heartbeat at: ${payload.daemon.heartbeatAtUnixMs}`);
-        lines.push(`Updated at: ${payload.daemon.updatedAtUnixMs}`);
-        lines.push(`IPC ready: ${formatBool(payload.daemon.ipcReady)}`);
-        lines.push(`RPC reachable: ${formatBool(payload.daemon.rpcReachable)}`);
-        lines.push(`Core best height: ${formatMaybe(payload.daemon.coreBestHeight)}`);
-        lines.push(`Core best hash: ${formatMaybe(payload.daemon.coreBestHash)}`);
-        lines.push(`Applied tip height: ${formatMaybe(payload.daemon.appliedTipHeight)}`);
-        lines.push(`Applied tip hash: ${formatMaybe(payload.daemon.appliedTipHash)}`);
-        lines.push(`Snapshot sequence: ${formatMaybe(payload.daemon.snapshotSeq)}`);
-        lines.push(`Backlog blocks: ${formatMaybe(payload.daemon.backlogBlocks)}`);
-        lines.push(`Reorg depth: ${formatMaybe(payload.daemon.reorgDepth)}`);
-        lines.push(`Active snapshots: ${payload.daemon.activeSnapshotCount}`);
-        lines.push(`Last applied at: ${formatMaybe(payload.daemon.lastAppliedAtUnixMs)}`);
+        managedServiceEntries.push(serviceStatusEntry("Daemon state", payload.daemon.state, daemonStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Process id", formatMaybe(payload.daemon.processId), daemonStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Daemon instance", payload.daemon.daemonInstanceId, daemonStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Runtime root", payload.daemon.runtimeRoot, daemonStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Schema version", payload.daemon.schemaVersion, daemonStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Started at", String(payload.daemon.startedAtUnixMs), daemonStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Heartbeat at", String(payload.daemon.heartbeatAtUnixMs), daemonStateOk));
+        managedServiceEntries.push(serviceStatusEntry("Updated at", String(payload.daemon.updatedAtUnixMs), daemonStateOk));
+        managedServiceEntries.push(serviceStatusEntry("IPC ready", formatBool(payload.daemon.ipcReady), payload.daemon.ipcReady));
+        managedServiceEntries.push(serviceStatusEntry("RPC reachable", formatBool(payload.daemon.rpcReachable), payload.daemon.rpcReachable));
         if (payload.daemon.lastError !== null) {
-            lines.push(`Daemon error: ${payload.daemon.lastError}`);
+            managedServiceEntries.push(serviceStatusEntry("Daemon error", payload.daemon.lastError, false));
         }
     }
     else {
-        lines.push("Daemon state: unavailable");
-    }
-    if (payload.compatibility === "unreachable") {
-        lines.push("Recommended next step: Run `cogcoin indexer start` to start the managed Cogcoin indexer.");
+        managedServiceEntries.push(serviceStatusEntry("Daemon state", "unavailable", false));
     }
-    return `${lines.join("\n")}\n`;
+    const indexerStateEntries = payload.daemon !== null
+        ? [
+            serviceStatusEntry("Core best height", formatMaybe(payload.daemon.coreBestHeight), daemonStateOk),
+            serviceStatusEntry("Core best hash", formatMaybe(payload.daemon.coreBestHash), daemonStateOk),
+            serviceStatusEntry("Applied tip height", formatMaybe(payload.daemon.appliedTipHeight), daemonStateOk),
+            serviceStatusEntry("Applied tip hash", formatMaybe(payload.daemon.appliedTipHash), daemonStateOk),
+            serviceStatusEntry("Snapshot sequence", formatMaybe(payload.daemon.snapshotSeq), daemonStateOk),
+            serviceStatusEntry("Backlog blocks", formatMaybe(payload.daemon.backlogBlocks), daemonStateOk),
+            serviceStatusEntry("Reorg depth", formatMaybe(payload.daemon.reorgDepth), daemonStateOk),
+            serviceStatusEntry("Active snapshots", String(payload.daemon.activeSnapshotCount), daemonStateOk),
+            serviceStatusEntry("Last applied at", formatMaybe(payload.daemon.lastAppliedAtUnixMs), daemonStateOk),
+        ]
+        : [serviceStatusEntry("Daemon state", "unavailable", false)];
+    return formatSectionedServiceStatusReport({
+        title: "Indexer Status",
+        sections: [
+            {
+                header: "Paths",
+                entries: [
+                    serviceStatusEntry("Bitcoin datadir", payload.dataDir, true),
+                    serviceStatusEntry("Wallet root", payload.walletRootId, true),
+                    serviceStatusEntry("Wallet root source", payload.walletRootSource, true),
+                ],
+            },
+            {
+                header: "Managed Service",
+                entries: managedServiceEntries,
+            },
+            {
+                header: "Indexer State",
+                entries: indexerStateEntries,
+            },
+        ],
+        nextStep: payload.compatibility === "unreachable"
+            ? "Run `cogcoin indexer start` to start the managed Cogcoin indexer."
+            : null,
+    });
 }
 function buildStatusMessages(payload) {
     const warnings = [];
@@ -287,7 +303,7 @@ export async function runServiceRuntimeCommand(parsed, context) {
             return 0;
         }
         if (parsed.command === "bitcoin-start") {
-            const resolution = await resolveEffectiveWalletRootId(dataDir, context);
+            const resolution = await resolveEffectiveWalletRootId(context);
             const probe = await context.probeManagedBitcoindService({
                 dataDir,
                 chain: "main",
@@ -298,7 +314,7 @@ export async function runServiceRuntimeCommand(parsed, context) {
             await context.attachManagedBitcoindService({
                 dataDir,
                 chain: "main",
-                startHeight: genesis.genesisBlock,
+                startHeight: resolveCogcoinProcessingStartHeight(genesis),
                 walletRootId: resolution.walletRootId,
             });
             const bitcoindStatus = probe.compatibility === "compatible" ? "already-running" : "started";
@@ -324,7 +340,7 @@ export async function runServiceRuntimeCommand(parsed, context) {
             return 0;
         }
         if (parsed.command === "bitcoin-stop") {
-            const resolution = await resolveEffectiveWalletRootId(dataDir, context);
+            const resolution = await resolveEffectiveWalletRootId(context);
             const indexer = await context.stopIndexerDaemonService({
                 dataDir,
                 walletRootId: resolution.walletRootId,
@@ -349,7 +365,7 @@ export async function runServiceRuntimeCommand(parsed, context) {
             return 0;
         }
         if (parsed.command === "indexer-start") {
-            const resolution = await resolveEffectiveWalletRootId(dataDir, context);
+            const resolution = await resolveEffectiveWalletRootId(context);
             const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
             await context.ensureDirectory(dirname(dbPath));
             const genesis = await loadBundledGenesisParameters();
@@ -362,7 +378,7 @@ export async function runServiceRuntimeCommand(parsed, context) {
             await context.attachManagedBitcoindService({
                 dataDir,
                 chain: "main",
-                startHeight: genesis.genesisBlock,
+                startHeight: resolveCogcoinProcessingStartHeight(genesis),
                 walletRootId: resolution.walletRootId,
             });
             const indexerProbe = await context.probeIndexerDaemon({
@@ -401,7 +417,7 @@ export async function runServiceRuntimeCommand(parsed, context) {
             return 0;
         }
         if (parsed.command === "indexer-stop") {
-            const resolution = await resolveEffectiveWalletRootId(dataDir, context);
+            const resolution = await resolveEffectiveWalletRootId(context);
             const indexer = await context.stopIndexerDaemonService({
                 dataDir,
                 walletRootId: resolution.walletRootId,

package/dist/cli/commands/status.js

@@ -6,11 +6,13 @@ import { createSuccessEnvelope, describeCanonicalCommand, writeJsonValue } from
 export async function runStatusCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
     const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+    const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
     await context.ensureDirectory(dirname(dbPath));
     const readContext = await context.openWalletReadContext({
         dataDir,
         databasePath: dbPath,
         secretProvider: context.walletSecretProvider,
+        paths: runtimePaths,
     });
     try {
         if (parsed.outputMode === "json") {

package/dist/cli/commands/sync.js

@@ -1,11 +1,20 @@
 import { dirname } from "node:path";
 import { formatManagedSyncErrorMessage } from "../../bitcoind/errors.js";
+import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolution.js";
 import { writeLine } from "../io.js";
 import { classifyCliError } from "../output.js";
 import { createStopSignalWatcher, waitForCompletionOrStop } from "../signals.js";
+import { confirmGetblockArchiveRestart } from "./getblock-archive-restart.js";
 export async function runSyncCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
     const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+    const walletRoot = await resolveWalletRootIdFromLocalArtifacts({
+        paths: context.resolveWalletRuntimePaths(),
+        provider: context.walletSecretProvider,
+        loadRawWalletStateEnvelope: context.loadRawWalletStateEnvelope,
+        loadUnlockSession: context.loadUnlockSession,
+        loadWalletExplicitLock: context.loadWalletExplicitLock,
+    });
     await context.ensureDirectory(dirname(dbPath));
     const store = await context.openSqliteStore({ filename: dbPath });
     let storeOwned = true;
@@ -14,7 +23,9 @@ export async function runSyncCommand(parsed, context) {
             store,
             databasePath: dbPath,
             dataDir,
+            walletRootId: walletRoot.walletRootId,
             progressOutput: parsed.progressOutput,
+            confirmGetblockArchiveRestart: async (options) => confirmGetblockArchiveRestart(parsed, context, options),
         });
         storeOwned = false;
         const stopWatcher = createStopSignalWatcher(context.signalSource, context.stderr, client, context.forceExit);