@cogcoin/client 0.5.15 → 1.0.1

package/dist/cli/commands/sync.js

@@ -1,100 +1,29 @@
 import { dirname } from "node:path";
 import { formatManagedSyncErrorMessage } from "../../bitcoind/errors.js";
-import { formatBytes, formatDuration } from "../../bitcoind/progress/formatting.js";
 import { FileLockBusyError, acquireFileLock } from "../../wallet/fs/lock.js";
 import { resolveWalletRootIdFromLocalArtifacts } from "../../wallet/root-resolution.js";
+import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 import { usesTtyProgress, writeLine } from "../io.js";
 import { classifyCliError, formatCliTextError } from "../output.js";
+import { createTerminalPrompter } from "../prompt.js";
 import { createStopSignalWatcher, waitForCompletionOrStop } from "../signals.js";
-const SYNC_PROGRESS_LOG_INTERVAL_MS = 5_000;
-function createSyncProgressReporter(options) {
-    let lastPhase = null;
-    let lastMessage = "";
-    let lastDownloadPrintedAt = 0;
-    let lastDownloadBytes = null;
-    let lastImportPrintedAt = 0;
-    let lastImportBlocks = null;
-    const infoEnabled = options.progressOutput !== "none";
-    function shouldPrintEntryMessage(message, phase) {
-        if (message === "Waiting to start managed sync." || message === "Sync complete.") {
-            return false;
-        }
-        if (message.startsWith("Warning:")) {
-            return true;
-        }
-        if (!infoEnabled) {
-            return false;
-        }
-        if (phase === "getblock_archive_download" || phase === "getblock_archive_import") {
-            return true;
-        }
-        return phase === "snapshot_download"
-            || phase === "wait_headers_for_snapshot"
-            || phase === "load_snapshot"
-            || phase === "bitcoin_sync"
-            || phase === "cogcoin_sync"
-            || message.includes("Getblock manifest")
-            || message.startsWith("Fetching Getblock manifest.")
-            || message.startsWith("Refreshing Getblock manifest.")
-            || message.startsWith("Using Getblock range ");
+import { createSyncProgressReporter } from "../sync-progress.js";
+import { formatBalanceReport } from "../wallet-format.js";
+async function writePostSyncBalanceReport(options) {
+    const provider = withInteractiveWalletSecretProvider(options.context.walletSecretProvider, options.context.createPrompter?.() ?? createTerminalPrompter(options.context.stdin, options.context.stdout));
+    const readContext = await options.context.openWalletReadContext({
+        dataDir: options.dataDir,
+        databasePath: options.databasePath,
+        secretProvider: provider,
+        walletControlLockHeld: true,
+        paths: options.runtimePaths,
+    });
+    try {
+        writeLine(options.context.stdout, formatBalanceReport(readContext));
     }
-    function formatDownloadLine(label, event) {
-        const current = event.progress.downloadedBytes ?? 0;
-        const total = event.progress.totalBytes ?? 0;
-        const percent = event.progress.percent ?? (total > 0 ? (current / total) * 100 : 0);
-        const speed = event.progress.bytesPerSecond === null ? "--" : `${formatBytes(event.progress.bytesPerSecond)}/s`;
-        return `${label}: ${percent.toFixed(2)}% (${formatBytes(current)} / ${formatBytes(total)}, ${speed}, ETA ${formatDuration(event.progress.etaSeconds)})`;
+    finally {
+        await readContext.close().catch(() => undefined);
     }
-    return (event) => {
-        const message = event.progress.message.trim();
-        const phaseChanged = event.phase !== lastPhase;
-        const messageChanged = message !== lastMessage;
-        if ((phaseChanged || messageChanged) && shouldPrintEntryMessage(message, event.phase)) {
-            options.write(message);
-        }
-        if (infoEnabled && event.phase === "getblock_archive_download") {
-            const now = Date.now();
-            const currentBytes = event.progress.downloadedBytes ?? 0;
-            const isComplete = (event.progress.percent ?? 0) >= 100;
-            const shouldPrintMilestone = phaseChanged
-                || lastDownloadBytes !== currentBytes && (isComplete
-                    || now - lastDownloadPrintedAt >= SYNC_PROGRESS_LOG_INTERVAL_MS);
-            if (shouldPrintMilestone) {
-                options.write(formatDownloadLine("Getblock download", event));
-                lastDownloadPrintedAt = now;
-                lastDownloadBytes = currentBytes;
-            }
-        }
-        else if (infoEnabled && event.phase === "snapshot_download") {
-            const now = Date.now();
-            const currentBytes = event.progress.downloadedBytes ?? 0;
-            const isComplete = (event.progress.percent ?? 0) >= 100;
-            const shouldPrintMilestone = phaseChanged
-                || lastDownloadBytes !== currentBytes && (isComplete
-                    || now - lastDownloadPrintedAt >= SYNC_PROGRESS_LOG_INTERVAL_MS);
-            if (shouldPrintMilestone) {
-                options.write(formatDownloadLine("Snapshot download", event));
-                lastDownloadPrintedAt = now;
-                lastDownloadBytes = currentBytes;
-            }
-        }
-        else if (infoEnabled && event.phase === "getblock_archive_import") {
-            const now = Date.now();
-            const currentBlocks = event.progress.blocks ?? 0;
-            const targetBlocks = event.progress.targetHeight ?? currentBlocks;
-            const isComplete = currentBlocks >= targetBlocks;
-            const shouldPrintMilestone = phaseChanged
-                || lastImportBlocks !== currentBlocks && (isComplete
-                    || now - lastImportPrintedAt >= SYNC_PROGRESS_LOG_INTERVAL_MS);
-            if (shouldPrintMilestone) {
-                options.write(`Getblock import: Bitcoin ${currentBlocks.toLocaleString()} / ${targetBlocks.toLocaleString()}`);
-                lastImportPrintedAt = now;
-                lastImportBlocks = currentBlocks;
-            }
-        }
-        lastPhase = event.phase;
-        lastMessage = message;
-    };
 }
 export async function runSyncCommand(parsed, context) {
     const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
@@ -104,13 +33,13 @@ export async function runSyncCommand(parsed, context) {
     let controlLock = null;
     let store = null;
     let storeOwned = true;
+    let client = null;
+    let clientClosed = false;
     try {
         const walletRoot = await resolveWalletRootIdFromLocalArtifacts({
             paths: runtimePaths,
             provider: context.walletSecretProvider,
             loadRawWalletStateEnvelope: context.loadRawWalletStateEnvelope,
-            loadUnlockSession: context.loadUnlockSession,
-            loadWalletExplicitLock: context.loadWalletExplicitLock,
         });
         try {
             controlLock = await acquireFileLock(runtimePaths.walletControlLockPath, {
@@ -126,7 +55,7 @@ export async function runSyncCommand(parsed, context) {
         }
         await context.ensureDirectory(dirname(dbPath));
         store = await context.openSqliteStore({ filename: dbPath });
-        const client = await context.openManagedBitcoindClient({
+        client = await context.openManagedBitcoindClient({
             store,
             databasePath: dbPath,
             dataDir,
@@ -147,6 +76,32 @@ export async function runSyncCommand(parsed, context) {
                 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();
+                if (typeof client.playSyncCompletionScene === "function") {
+                    await client.playSyncCompletionScene().catch(() => undefined);
+                }
+                try {
+                    await detachPromise;
+                    await client.close();
+                    clientClosed = true;
+                    writeLine(context.stderr, "Detached cleanly; background indexer follow resumed.");
+                    await writePostSyncBalanceReport({
+                        context,
+                        dataDir,
+                        databasePath: dbPath,
+                        runtimePaths,
+                    }).catch(() => undefined);
+                    return 0;
+                }
+                catch {
+                    writeLine(context.stderr, "Detach failed before background indexer follow was confirmed.");
+                    return 1;
+                }
+            }
             if (typeof client.playSyncCompletionScene === "function") {
                 const completionOutcome = await waitForCompletionOrStop(client.playSyncCompletionScene().catch(() => undefined), stopWatcher);
                 if (completionOutcome.kind === "stopped") {
@@ -161,7 +116,9 @@ export async function runSyncCommand(parsed, context) {
         }
         finally {
             stopWatcher.cleanup();
-            await client.close();
+            if (!clientClosed) {
+                await client.close();
+            }
         }
     }
     catch (error) {

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

@@ -1,11 +1,14 @@
-import { parseUnlockDurationToMs } from "../../wallet/lifecycle.js";
-import { buildInitMutationData, buildResetMutationData, buildRestoreMutationData, buildWalletDeleteMutationData, buildUnlockMutationData, buildRepairMutationData, buildWalletExportMutationData, buildWalletImportMutationData, buildWalletLockMutationData, } from "../mutation-json.js";
-import { buildResetPreviewData, buildRepairPreviewData, buildWalletLockPreviewData, } from "../preview-json.js";
+import { buildInitMutationData, buildResetMutationData, buildRestoreMutationData, buildWalletDeleteMutationData, buildRepairMutationData, } from "../mutation-json.js";
+import { buildResetPreviewData, buildRepairPreviewData, } from "../preview-json.js";
 import { writeLine } from "../io.js";
 import { createTerminalPrompter } from "../prompt.js";
 import { createPreviewSuccessEnvelope, createMutationSuccessEnvelope, describeCanonicalCommand, resolvePreviewJsonSchema, resolveStableMutationJsonSchema, writeHandledCliError, writeJsonValue, } from "../output.js";
-import { formatNextStepLines, getFundingQuickstartGuidance, getInitNextSteps, getRestoreNextSteps, } from "../workflow-hints.js";
+import { loadWelcomeArtText } from "../art.js";
+import { formatNextStepLines, getFundingQuickstartGuidance, getInitNextSteps, getRestoreNextSteps, getSetupUnlockGuidanceLines, } from "../workflow-hints.js";
 import { createOwnedLockCleanupSignalWatcher, waitForCompletionOrStop, } from "../signals.js";
+import { runSyncCommand } from "./sync.js";
+import { CLIENT_PASSWORD_SETUP_AUTO_UNLOCK_SECONDS } from "../../wallet/state/client-password.js";
+import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 function createCommandPrompter(parsed, context) {
     return parsed.outputMode !== "text"
         ? createTerminalPrompter(context.stdin, context.stderr)
@@ -21,24 +24,32 @@ function getResetWarnings(result) {
         ? ["Some existing Cogcoin secret-provider entries could not be discovered from the remaining local wallet artifacts and may need manual cleanup."]
         : [];
 }
+function writeSetupUnlockGuidance(stdout) {
+    for (const line of getSetupUnlockGuidanceLines(CLIENT_PASSWORD_SETUP_AUTO_UNLOCK_SECONDS)) {
+        writeLine(stdout, line);
+    }
+}
 function getResetNextSteps(result) {
     return result.walletAction === "deleted" || result.walletAction === "not-present"
         ? ["Run `cogcoin init` to create a new wallet."]
         : ["Run `cogcoin sync` to bootstrap assumeutxo and the managed Bitcoin/indexer state."];
 }
+function getRepairNextSteps() {
+    return ["Run `cogcoin status` to review the repaired local state."];
+}
 function formatResetBitcoinDataDirStatus(result) {
     if (result.bitcoinDataDir.status === "outside-reset-scope") {
         return "preserved (outside reset scope)";
     }
     return result.bitcoinDataDir.status;
 }
-function resetTextEntry(label, value, ok) {
+function sectionTextEntry(label, value, ok) {
     return {
         text: `${label}: ${value}`,
         ok,
     };
 }
-function formatResetSection(header, entries) {
+function formatAdminSection(header, entries) {
     return [header, ...entries.map((entry) => `${entry.ok ? "✓" : "✗"} ${entry.text}`)].join("\n");
 }
 function formatResetResultText(result) {
@@ -47,30 +58,30 @@ function formatResetResultText(result) {
     const secretCleanupOk = result.secretCleanupStatus !== "unknown" && result.secretCleanupStatus !== "failed";
     const managedCleanupOk = result.stoppedProcesses.survivors === 0;
     const outcomeEntries = [
-        resetTextEntry("Wallet action", result.walletAction, true),
-        resetTextEntry("Snapshot", result.bootstrapSnapshot.status, true),
-        resetTextEntry("Bitcoin datadir", formatResetBitcoinDataDirStatus(result), true),
-        resetTextEntry("Secret cleanup", result.secretCleanupStatus, secretCleanupOk),
+        sectionTextEntry("Wallet action", result.walletAction, true),
+        sectionTextEntry("Snapshot", result.bootstrapSnapshot.status, true),
+        sectionTextEntry("Bitcoin datadir", formatResetBitcoinDataDirStatus(result), true),
+        sectionTextEntry("Secret cleanup", result.secretCleanupStatus, secretCleanupOk),
     ];
     if (result.walletAction !== "retain-mnemonic" && result.walletOldRootId !== null) {
-        outcomeEntries.push(resetTextEntry("Previous wallet root", result.walletOldRootId, true));
+        outcomeEntries.push(sectionTextEntry("Previous wallet root", result.walletOldRootId, true));
     }
     if (result.walletAction !== "retain-mnemonic" && result.walletNewRootId !== null) {
-        outcomeEntries.push(resetTextEntry("New wallet root", result.walletNewRootId, true));
+        outcomeEntries.push(sectionTextEntry("New wallet root", result.walletNewRootId, true));
     }
     const sections = [
-        formatResetSection("Paths", [
-            resetTextEntry("Data root", result.dataRoot, true),
+        formatAdminSection("Paths", [
+            sectionTextEntry("Data root", result.dataRoot, true),
         ]),
-        formatResetSection("Reset Outcome", outcomeEntries),
-        formatResetSection("Managed Cleanup", [
-            resetTextEntry("Managed bitcoind processes stopped", String(result.stoppedProcesses.managedBitcoind), managedCleanupOk),
-            resetTextEntry("Indexer daemons stopped", String(result.stoppedProcesses.indexerDaemon), managedCleanupOk),
-            resetTextEntry("Background miners stopped", String(result.stoppedProcesses.backgroundMining), managedCleanupOk),
+        formatAdminSection("Reset Outcome", outcomeEntries),
+        formatAdminSection("Managed Cleanup", [
+            sectionTextEntry("Managed bitcoind processes stopped", String(result.stoppedProcesses.managedBitcoind), managedCleanupOk),
+            sectionTextEntry("Indexer daemons stopped", String(result.stoppedProcesses.indexerDaemon), managedCleanupOk),
+            sectionTextEntry("Background miners stopped", String(result.stoppedProcesses.backgroundMining), managedCleanupOk),
         ]),
     ];
     if (warnings.length > 0) {
-        sections.push(formatResetSection("Warnings", warnings.map((warning) => resetTextEntry("Warning", warning, false))));
+        sections.push(formatAdminSection("Warnings", warnings.map((warning) => sectionTextEntry("Warning", warning, false))));
     }
     const parts = [
         "\n⛭ Cogcoin Reset ⛭",
@@ -81,6 +92,68 @@ function formatResetResultText(result) {
     }
     return parts.join("\n\n");
 }
+function isRepairMiningResumeActionOk(action) {
+    return action === "none"
+        || action === "skipped-not-resumable"
+        || action === "resumed-background";
+}
+function buildRepairWarningEntries(result) {
+    const entries = [];
+    if (result.miningResumeError !== null) {
+        entries.push(sectionTextEntry("Mining resume error", result.miningResumeError, false));
+    }
+    for (const warning of getRepairWarnings(result)) {
+        if (result.miningResumeError !== null && warning.includes(result.miningResumeError)) {
+            continue;
+        }
+        entries.push(sectionTextEntry("Warning", warning, false));
+    }
+    return entries;
+}
+function formatRepairResultText(result) {
+    const nextStep = getRepairNextSteps()[0] ?? null;
+    const warningEntries = buildRepairWarningEntries(result);
+    const sections = [
+        formatAdminSection("Wallet", [
+            sectionTextEntry("Wallet root", result.walletRootId, true),
+            sectionTextEntry("Recovered from backup", result.recoveredFromBackup ? "yes" : "no", true),
+            sectionTextEntry("Managed Core wallet recreated", result.recreatedManagedCoreWallet ? "yes" : "no", true),
+        ]),
+        formatAdminSection("Managed Bitcoind", [
+            sectionTextEntry("Managed bitcoind action", result.bitcoindServiceAction, true),
+            sectionTextEntry("Managed bitcoind compatibility issue", result.bitcoindCompatibilityIssue, result.bitcoindCompatibilityIssue === "none"),
+            sectionTextEntry("Managed Core replica action", result.managedCoreReplicaAction, true),
+            sectionTextEntry("Managed bitcoind post-repair health", result.bitcoindPostRepairHealth, result.bitcoindPostRepairHealth === "ready"),
+        ]),
+        formatAdminSection("Indexer", [
+            sectionTextEntry("Indexer database reset", result.resetIndexerDatabase ? "yes" : "no", true),
+            sectionTextEntry("Indexer daemon action", result.indexerDaemonAction, true),
+            sectionTextEntry("Indexer compatibility issue", result.indexerCompatibilityIssue, result.indexerCompatibilityIssue === "none"),
+            sectionTextEntry("Indexer post-repair health", result.indexerPostRepairHealth, result.indexerPostRepairHealth === "synced"),
+        ]),
+        formatAdminSection("Mining", [
+            sectionTextEntry("Mining mode before repair", result.miningPreRepairRunMode, true),
+            sectionTextEntry("Mining resume action", result.miningResumeAction, isRepairMiningResumeActionOk(result.miningResumeAction)),
+            sectionTextEntry("Mining mode after repair", result.miningPostRepairRunMode, true),
+        ]),
+    ];
+    if (result.note !== null) {
+        sections.push(formatAdminSection("Notes", [
+            sectionTextEntry("Note", result.note, true),
+        ]));
+    }
+    if (warningEntries.length > 0) {
+        sections.push(formatAdminSection("Warnings", warningEntries));
+    }
+    const parts = [
+        "\n⛭ Cogcoin Repair ⛭",
+        ...sections,
+    ];
+    if (nextStep !== null) {
+        parts.push(`Next step: ${nextStep}`);
+    }
+    return parts.join("\n\n");
+}
 export async function runWalletAdminCommand(parsed, context) {
     const runtimePaths = context.resolveWalletRuntimePaths(parsed.seedName);
     const stopWatcher = createOwnedLockCleanupSignalWatcher(context.signalSource, context.forceExit, [
@@ -89,15 +162,17 @@ export async function runWalletAdminCommand(parsed, context) {
         runtimePaths.bitcoindLockPath,
         runtimePaths.indexerDaemonLockPath,
     ]);
+    let shouldAutoSyncAfterInit = false;
     try {
         const outcome = await waitForCompletionOrStop((async () => {
             const provider = context.walletSecretProvider;
             if (parsed.command === "init" || parsed.command === "wallet-init") {
                 const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
                 const prompter = createCommandPrompter(parsed, context);
+                const interactiveProvider = withInteractiveWalletSecretProvider(provider, prompter);
                 const result = await context.initializeWallet({
                     dataDir,
-                    provider,
+                    provider: interactiveProvider,
                     prompter,
                     paths: runtimePaths,
                 });
@@ -109,22 +184,42 @@ export async function runWalletAdminCommand(parsed, context) {
                     }));
                     return 0;
                 }
-                writeLine(context.stdout, `Wallet initialized.`);
-                writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
-                writeLine(context.stdout, `Funding address: ${result.fundingAddress}`);
-                writeLine(context.stdout, `Unlocked until: ${new Date(result.unlockUntilUnixMs).toISOString()}`);
-                writeLine(context.stdout, `Quickstart: ${getFundingQuickstartGuidance()}`);
-                for (const line of formatNextStepLines(nextSteps)) {
-                    writeLine(context.stdout, line);
+                writeLine(context.stdout, "");
+                writeLine(context.stdout, loadWelcomeArtText());
+                writeLine(context.stdout, "");
+                writeLine(context.stdout, result.walletAction === "already-initialized"
+                    ? "Wallet already initialized."
+                    : "Wallet initialized.");
+                if (result.walletAction === "already-initialized") {
+                    writeLine(context.stdout, "");
+                    writeLine(context.stdout, "Wallet");
+                    writeLine(context.stdout, `✓ Client password: ${result.passwordAction}`);
+                    writeLine(context.stdout, `✓ Wallet root: ${result.walletRootId}`);
+                    writeLine(context.stdout, `✓ Funding address: ${result.fundingAddress}`);
+                    if (result.passwordAction !== "already-configured") {
+                        writeSetupUnlockGuidance(context.stdout);
+                    }
+                }
+                else {
+                    writeLine(context.stdout, `Client password: ${result.passwordAction}`);
+                    if (result.passwordAction !== "already-configured") {
+                        writeSetupUnlockGuidance(context.stdout);
+                    }
+                    writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
+                    writeLine(context.stdout, `Funding address: ${result.fundingAddress}`);
                 }
+                writeLine(context.stdout, "");
+                writeLine(context.stdout, `Quickstart: ${getFundingQuickstartGuidance()}`);
+                shouldAutoSyncAfterInit = true;
                 return 0;
             }
             if (parsed.command === "restore" || parsed.command === "wallet-restore") {
                 const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
                 const prompter = createCommandPrompter(parsed, context);
+                const interactiveProvider = withInteractiveWalletSecretProvider(provider, prompter);
                 const result = await context.restoreWalletFromMnemonic({
                     dataDir,
-                    provider,
+                    provider: interactiveProvider,
                     prompter,
                     paths: runtimePaths,
                 });
@@ -139,9 +234,11 @@ export async function runWalletAdminCommand(parsed, context) {
                     return 0;
                 }
                 writeLine(context.stdout, `Wallet seed "${result.seedName}" restored from mnemonic.`);
+                if (result.passwordAction !== "already-configured") {
+                    writeSetupUnlockGuidance(context.stdout);
+                }
                 writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
                 writeLine(context.stdout, `Funding address: ${result.fundingAddress}`);
-                writeLine(context.stdout, `Unlocked until: ${new Date(result.unlockUntilUnixMs).toISOString()}`);
                 writeLine(context.stdout, "Note: Managed Bitcoin/indexer bootstrap is deferred until you run `cogcoin sync`.");
                 for (const warning of result.warnings ?? []) {
                     writeLine(context.stdout, `Warning: ${warning}`);
@@ -154,9 +251,10 @@ export async function runWalletAdminCommand(parsed, context) {
             if (parsed.command === "wallet-delete") {
                 const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
                 const prompter = createCommandPrompter(parsed, context);
+                const interactiveProvider = withInteractiveWalletSecretProvider(provider, prompter);
                 const result = await context.deleteImportedWalletSeed({
                     dataDir,
-                    provider,
+                    provider: interactiveProvider,
                     prompter,
                     assumeYes: parsed.assumeYes,
                     paths: runtimePaths,
@@ -172,29 +270,13 @@ export async function runWalletAdminCommand(parsed, context) {
             if (parsed.command === "wallet-show-mnemonic") {
                 const prompter = createCommandPrompter(parsed, context);
                 await context.showWalletMnemonic({
-                    provider,
+                    provider: withInteractiveWalletSecretProvider(provider, prompter),
                     prompter,
                     paths: runtimePaths,
                 });
                 return 0;
             }
             const dbPath = parsed.dbPath ?? context.resolveDefaultClientDatabasePath();
-            if (parsed.command === "unlock" || parsed.command === "wallet-unlock") {
-                const durationMs = parseUnlockDurationToMs(parsed.unlockFor);
-                const result = await context.unlockWallet({
-                    provider,
-                    unlockDurationMs: durationMs,
-                    paths: runtimePaths,
-                });
-                if (parsed.outputMode === "json") {
-                    writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), "unlocked", buildUnlockMutationData(result)));
-                    return 0;
-                }
-                writeLine(context.stdout, `Wallet unlocked.`);
-                writeLine(context.stdout, `Wallet root: ${result.state.walletRootId}`);
-                writeLine(context.stdout, `Unlocked until: ${new Date(result.unlockUntilUnixMs).toISOString()}`);
-                return 0;
-            }
             if (parsed.command === "reset") {
                 const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
                 if (parsed.outputMode === "preview-json") {
@@ -208,7 +290,7 @@ export async function runWalletAdminCommand(parsed, context) {
                 const prompter = createCommandPrompter(parsed, context);
                 const result = await context.resetWallet({
                     dataDir,
-                    provider,
+                    provider: withInteractiveWalletSecretProvider(provider, prompter),
                     prompter,
                 });
                 if (parsed.outputMode === "json") {
@@ -221,113 +303,33 @@ export async function runWalletAdminCommand(parsed, context) {
                 writeLine(context.stdout, formatResetResultText(result));
                 return 0;
             }
-            if (parsed.command === "wallet-export") {
-                const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
-                const prompter = createCommandPrompter(parsed, context);
-                const result = await context.exportWallet({
-                    archivePath: parsed.args[0],
-                    dataDir,
-                    databasePath: dbPath,
-                    provider,
-                    prompter,
-                    paths: runtimePaths,
-                });
-                if (parsed.outputMode === "json") {
-                    writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), "exported", buildWalletExportMutationData(result)));
-                    return 0;
-                }
-                writeLine(context.stdout, `Wallet exported.`);
-                writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
-                writeLine(context.stdout, `Archive path: ${result.archivePath}`);
-                return 0;
-            }
-            if (parsed.command === "wallet-import") {
-                const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
-                const prompter = createCommandPrompter(parsed, context);
-                const result = await context.importWallet({
-                    archivePath: parsed.args[0],
-                    dataDir,
-                    databasePath: dbPath,
-                    provider,
-                    prompter,
-                    paths: runtimePaths,
-                });
-                if (parsed.outputMode === "json") {
-                    writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), describeCanonicalCommand(parsed), "imported", buildWalletImportMutationData(result)));
-                    return 0;
-                }
-                writeLine(context.stdout, `Wallet imported.`);
-                writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
-                writeLine(context.stdout, `Funding address: ${result.fundingAddress}`);
-                writeLine(context.stdout, `Unlocked until: ${new Date(result.unlockUntilUnixMs).toISOString()}`);
-                return 0;
-            }
-            if (parsed.command === "wallet-lock") {
-                const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
-                const result = await context.lockWallet({
-                    dataDir,
-                    provider,
-                    paths: runtimePaths,
-                });
-                if (parsed.outputMode === "preview-json") {
-                    writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), "locked", buildWalletLockPreviewData(result)));
-                    return 0;
-                }
-                if (parsed.outputMode === "json") {
-                    writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), "cogcoin wallet lock", "locked", buildWalletLockMutationData(result)));
-                    return 0;
-                }
-                writeLine(context.stdout, `Wallet locked.`);
-                writeLine(context.stdout, `Wallet root: ${result.walletRootId ?? "none"}`);
-                return 0;
-            }
             if (parsed.command === "repair") {
                 const dataDir = parsed.dataDir ?? context.resolveDefaultBitcoindDataDir();
+                const repairProvider = parsed.outputMode === "preview-json"
+                    ? provider
+                    : withInteractiveWalletSecretProvider(provider, createCommandPrompter(parsed, context));
                 const result = await context.repairWallet({
                     dataDir,
                     databasePath: dbPath,
-                    provider,
+                    provider: repairProvider,
                     assumeYes: parsed.assumeYes,
                     paths: runtimePaths,
                 });
                 if (parsed.outputMode === "preview-json") {
                     writeJsonValue(context.stdout, createPreviewSuccessEnvelope(resolvePreviewJsonSchema(parsed), describeCanonicalCommand(parsed), "completed", buildRepairPreviewData(result), {
-                        nextSteps: ["Run `cogcoin status` to review the repaired local state."],
+                        nextSteps: getRepairNextSteps(),
                         warnings: getRepairWarnings(result),
                     }));
                     return 0;
                 }
                 if (parsed.outputMode === "json") {
                     writeJsonValue(context.stdout, createMutationSuccessEnvelope(resolveStableMutationJsonSchema(parsed), "cogcoin repair", "completed", buildRepairMutationData(result), {
-                        nextSteps: ["Run `cogcoin status` to review the repaired local state."],
+                        nextSteps: getRepairNextSteps(),
                         warnings: getRepairWarnings(result),
                     }));
                     return 0;
                 }
-                writeLine(context.stdout, `Wallet repair completed.`);
-                writeLine(context.stdout, `Wallet root: ${result.walletRootId}`);
-                writeLine(context.stdout, `Recovered from backup: ${result.recoveredFromBackup ? "yes" : "no"}`);
-                writeLine(context.stdout, `Managed Core wallet recreated: ${result.recreatedManagedCoreWallet ? "yes" : "no"}`);
-                writeLine(context.stdout, `Managed bitcoind action: ${result.bitcoindServiceAction}`);
-                writeLine(context.stdout, `Managed bitcoind compatibility issue: ${result.bitcoindCompatibilityIssue}`);
-                writeLine(context.stdout, `Managed Core replica action: ${result.managedCoreReplicaAction}`);
-                writeLine(context.stdout, `Managed bitcoind post-repair health: ${result.bitcoindPostRepairHealth}`);
-                writeLine(context.stdout, `Indexer database reset: ${result.resetIndexerDatabase ? "yes" : "no"}`);
-                writeLine(context.stdout, `Indexer daemon action: ${result.indexerDaemonAction}`);
-                writeLine(context.stdout, `Indexer compatibility issue: ${result.indexerCompatibilityIssue}`);
-                writeLine(context.stdout, `Indexer post-repair health: ${result.indexerPostRepairHealth}`);
-                writeLine(context.stdout, `Mining mode before repair: ${result.miningPreRepairRunMode}`);
-                writeLine(context.stdout, `Mining resume action: ${result.miningResumeAction}`);
-                writeLine(context.stdout, `Mining mode after repair: ${result.miningPostRepairRunMode}`);
-                if (result.miningResumeError !== null) {
-                    writeLine(context.stdout, `Mining resume error: ${result.miningResumeError}`);
-                }
-                if (result.note !== null) {
-                    writeLine(context.stdout, `Note: ${result.note}`);
-                }
-                for (const warning of getRepairWarnings(result)) {
-                    writeLine(context.stdout, `Warning: ${warning}`);
-                }
+                writeLine(context.stdout, formatRepairResultText(result));
                 return 0;
             }
             writeLine(context.stderr, `wallet admin command not implemented: ${parsed.command}`);
@@ -336,6 +338,10 @@ export async function runWalletAdminCommand(parsed, context) {
         if (outcome.kind === "stopped") {
             return outcome.code;
         }
+        if (shouldAutoSyncAfterInit && outcome.value === 0) {
+            stopWatcher.cleanup();
+            return await runSyncCommand(parsed, context);
+        }
         return outcome.value;
     }
     catch (error) {