@cogcoin/client 1.1.8 → 1.1.9

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

@@ -3,8 +3,8 @@ import { formatBalanceReport, formatDetailedWalletStatusReport, formatDomainRepo
 import { writeLine } from "../io.js";
 import { findWalletDomain, listDomainFields } from "../../wallet/read/index.js";
 import { filterWalletDomains } from "../../wallet/read/index.js";
-import { normalizeListPage } from "../output.js";
-import { listFieldsForJson, listLocksForJson } from "../read-json.js";
+import { normalizeListPage } from "../pagination.js";
+import { listVisibleDomainFields, listVisibleWalletLocks } from "../wallet-read-helpers.js";
 import { formatNextStepLines, getAddressNextSteps, getFundingQuickstartGuidance, getIdsNextSteps, getLocksNextSteps, } from "../workflow-hints.js";
 import { withInteractiveWalletSecretProvider } from "../../wallet/state/provider.js";
 function activeDomainFilters(parsed) {
@@ -73,7 +73,7 @@ export async function runWalletReadCommand(parsed, context) {
                         limit: parsed.listAll ? null : (parsed.listLimit ?? defaultLimit),
                         all: parsed.listAll,
                     }));
-                    const locks = listLocksForJson(readContext, {
+                    const locks = listVisibleWalletLocks(readContext, {
                         claimableOnly: parsed.locksClaimableOnly,
                         reclaimableOnly: parsed.locksReclaimableOnly,
                     });
@@ -118,7 +118,7 @@ export async function runWalletReadCommand(parsed, context) {
             case "fields": {
                 const defaultLimit = 100;
                 const domainName = parsed.args[0];
-                const fields = listFieldsForJson(readContext, domainName);
+                const fields = listVisibleDomainFields(readContext, domainName);
                 if (readContext.snapshot !== null && fields === null) {
                     writeLine(context.stdout, formatFieldsReport(readContext, domainName, {
                         limit: parsed.listAll ? null : (parsed.listLimit ?? defaultLimit),

package/dist/cli/mutation-success.d.ts

@@ -7,8 +7,6 @@ export interface MutationSuccessNextSteps {
 export declare function commandMutationNextSteps(command: string): MutationSuccessNextSteps;
 export declare function workflowMutationNextSteps(nextSteps: readonly string[]): MutationSuccessNextSteps;
 export declare function writeMutationCommandSuccess(parsed: ParsedCliArgs, context: RequiredCliRunnerContext, options: {
-    data: unknown;
-    previewData?: unknown;
     reusedExisting: boolean;
     reusedMessage: string;
     fees?: WalletMutationFeeSummary | null;

package/dist/cli/output/classify.d.ts

@@ -0,0 +1,7 @@
+import type { CliErrorClassification } from "./types.js";
+export declare function classifyCliError(error: unknown): CliErrorClassification;
+export declare function isBlockedError(message: string): boolean;
+export declare function describeBusyLock(errorCode: string, error?: unknown): {
+    lockPath: string;
+    lockPurpose: string | null;
+} | null;

package/dist/cli/output/classify.js

@@ -0,0 +1,94 @@
+import { FileLockBusyError } from "../../wallet/fs/lock.js";
+export function classifyCliError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.startsWith("cli_")) {
+        return { exitCode: 2, errorCode: message, message };
+    }
+    if (/^wallet_init_confirmation_failed_word_\d+$/.test(message)) {
+        return { exitCode: 2, errorCode: message, message };
+    }
+    if (message === "mining_setup_invalid_provider"
+        || message === "mining_setup_missing_api_key"
+        || message === "mining_setup_missing_model_id"
+        || message === "mining_setup_canceled") {
+        return { exitCode: 2, errorCode: message, message };
+    }
+    if (message.endsWith("_typed_ack_required")) {
+        return { exitCode: 2, errorCode: message, message };
+    }
+    if (message === "wallet_typed_confirmation_rejected"
+        || message === "wallet_delete_confirmation_required"
+        || message === "wallet_prompt_value_required"
+        || message === "wallet_restore_mnemonic_invalid"
+        || message === "wallet_restore_replace_confirmation_required"
+        || message === "wallet_seed_name_invalid"
+        || message === "wallet_seed_name_reserved"
+        || message === "reset_wallet_choice_invalid") {
+        return { exitCode: 2, errorCode: message, message };
+    }
+    if (message === "not_found") {
+        return { exitCode: 3, errorCode: "not_found", message: "Requested object not found." };
+    }
+    if (message === "wallet_seed_not_found") {
+        return { exitCode: 3, errorCode: message, message };
+    }
+    if (message === "wallet_seed_index_invalid") {
+        return { exitCode: 4, errorCode: message, message };
+    }
+    if (message === "reset_process_shutdown_failed"
+        || message === "reset_data_root_delete_failed"
+        || message === "reset_secret_cleanup_failed"
+        || message === "reset_snapshot_preserve_failed") {
+        return { exitCode: 5, errorCode: message, message };
+    }
+    if (isBlockedError(message)) {
+        return { exitCode: 4, errorCode: message, message };
+    }
+    return { exitCode: 5, errorCode: message, message };
+}
+export function isBlockedError(message) {
+    if (message === "wallet_control_lock_busy"
+        || message.startsWith("file_lock_busy_")) {
+        return true;
+    }
+    if (message === "wallet_uninitialized"
+        || message === "local-state-corrupt"
+        || message === "wallet_already_initialized"
+        || message === "wallet_restore_requires_main_wallet"
+        || message === "wallet_seed_name_exists"
+        || message === "wallet_seed_not_found"
+        || message === "wallet_delete_main_not_supported"
+        || message === "wallet_repair_indexer_reset_requires_yes"
+        || message === "managed_bitcoind_service_version_mismatch"
+        || message === "managed_bitcoind_wallet_root_mismatch"
+        || message === "managed_bitcoind_runtime_mismatch"
+        || message === "indexer_daemon_service_version_mismatch"
+        || message === "indexer_daemon_wallet_root_mismatch"
+        || message === "indexer_daemon_schema_mismatch"
+        || message === "mine_setup_requires_tty"
+        || message === "mine_prompt_requires_tty"
+        || message === "mine_prompt_domain_not_mineable"
+        || message === "mining_preemption_timeout"
+        || message === "wallet_client_password_setup_required"
+        || message === "wallet_client_password_migration_required"
+        || message === "wallet_client_password_locked"
+        || message === "wallet_secret_provider_linux_runtime_error"
+        || message === "wallet_secret_provider_macos_runtime_error"
+        || message === "wallet_secret_provider_windows_runtime_error"
+        || message === "wallet_state_legacy_envelope_unsupported") {
+        return true;
+    }
+    return /(?:^|_)(?:locked|uninitialized|repair_required|requires_tty|typed_ack_required|confirmation_rejected|tip_mismatch|core_replica_not_ready|setup|no_eligible_sender|ambiguous_sender|insufficient|stale|paused|validation|catching_up|starting|unavailable|schema_mismatch|service_version_mismatch|wallet_root_mismatch|runtime_mismatch|replica_missing|replica_mismatch|failed)(?:_|$)/.test(message)
+        || /repair-required/.test(message);
+}
+export function describeBusyLock(errorCode, error) {
+    if (!errorCode.startsWith("file_lock_busy_")) {
+        return null;
+    }
+    return {
+        lockPath: errorCode.slice("file_lock_busy_".length),
+        lockPurpose: error instanceof FileLockBusyError
+            ? error.existingMetadata?.purpose ?? null
+            : null,
+    };
+}

package/dist/cli/output/render.d.ts

@@ -0,0 +1,2 @@
+import type { CliErrorPresentation } from "./types.js";
+export declare function formatCliTextErrorLines(presentation: CliErrorPresentation | null): string[] | null;

package/dist/cli/output/render.js

@@ -0,0 +1,13 @@
+export function formatCliTextErrorLines(presentation) {
+    if (presentation === null) {
+        return null;
+    }
+    const lines = [`What happened: ${presentation.what}`];
+    if (presentation.why !== null) {
+        lines.push(`Why: ${presentation.why}`);
+    }
+    if (presentation.next !== null) {
+        lines.push(`Next: ${presentation.next}`);
+    }
+    return lines;
+}

package/dist/cli/output/rules/cli-surface.d.ts

@@ -0,0 +1,2 @@
+import type { CliErrorPresentationRule } from "../types.js";
+export declare const cliSurfaceErrorRules: readonly CliErrorPresentationRule[];

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

@@ -0,0 +1,110 @@
+export const cliSurfaceErrorRules = [
+    ({ errorCode }) => {
+        if (errorCode === "cli_client_unlock_removed") {
+            return {
+                what: "`client unlock` was removed.",
+                why: "Cogcoin no longer shares unlocked client-password sessions across separate CLI commands.",
+                next: "Rerun password-aware commands in an interactive terminal so Cogcoin can prompt for the client password when needed.",
+            };
+        }
+        if (errorCode === "cli_client_lock_removed") {
+            return {
+                what: "`client lock` was removed.",
+                why: "Cogcoin no longer keeps reusable unlocked client-password sessions after a command exits.",
+                next: "Fresh CLI invocations start locked automatically and prompt when wallet-local secrets are needed.",
+            };
+        }
+        if (errorCode === "cli_restore_removed" || errorCode === "cli_wallet_restore_removed") {
+            return {
+                what: "Standalone restore commands were removed.",
+                why: "Cogcoin now uses `cogcoin init` as the single wallet setup entrypoint for both new and restored wallets.",
+                next: "Run `cogcoin init` and choose \"Restore existing wallet\".",
+            };
+        }
+        if (errorCode === "cli_wallet_delete_removed") {
+            return {
+                what: "`wallet delete` was removed.",
+                why: "Cogcoin no longer supports multiple local wallet seeds, so replacing the wallet now flows through reset and init.",
+                next: "Run `cogcoin reset`, choose \"clear wallet entropy\", then rerun `cogcoin init`.",
+            };
+        }
+        if (errorCode === "cli_seed_removed") {
+            return {
+                what: "`--seed` was removed.",
+                why: "Cogcoin now supports only a single local wallet instead of multiple named wallet seeds.",
+                next: "Use the current wallet directly, or run `cogcoin reset`, choose \"clear wallet entropy\", then rerun `cogcoin init` to import a different wallet.",
+            };
+        }
+        if (errorCode === "cli_missing_seed_name") {
+            return {
+                what: "Named wallet seeds were removed.",
+                why: "This version of Cogcoin no longer supports `--seed`.",
+                next: "Drop `--seed` and retry, or use reset plus init if you need to replace the wallet.",
+            };
+        }
+        if (errorCode === "cli_seed_not_supported_for_command" || errorCode === "wallet_init_seed_not_supported") {
+            return {
+                what: "Named wallet seeds were removed.",
+                why: "Cogcoin now operates on a single local wallet instead of multiple named wallet seeds.",
+                next: "Drop `--seed` and retry.",
+            };
+        }
+        if (errorCode === "cli_from_not_supported_for_command") {
+            return {
+                what: "`--from` is no longer supported.",
+                why: "Cogcoin now uses a single wallet address for local transaction authorship, so sender selection is no longer part of the CLI.",
+                next: "Retry the command without `--from`.",
+            };
+        }
+        if (errorCode === "cli_missing_satvb") {
+            return {
+                what: "A sat/vB value is required.",
+                why: "`--satvb` needs an explicit positive fee rate value in sat/vB for the mutation you are submitting.",
+                next: "Rerun the command with `--satvb <number>`.",
+            };
+        }
+        if (errorCode === "cli_invalid_satvb") {
+            return {
+                what: "The sat/vB value is invalid.",
+                why: "`--satvb` accepts only a positive finite decimal number such as `12` or `12.5`.",
+                next: "Choose a positive sat/vB value and retry.",
+            };
+        }
+        if (errorCode === "cli_satvb_not_supported_for_command") {
+            return {
+                what: "This command does not support `--satvb`.",
+                why: "The fee-rate override only applies to wallet mutation commands that build and broadcast transactions.",
+                next: "Drop `--satvb` for this command, or use it with a wallet mutation command like `cogcoin register` or `cogcoin send`.",
+            };
+        }
+        if (errorCode === "cli_anchor_clear_removed") {
+            return {
+                what: "`anchor clear` is no longer available.",
+                why: "Anchor is now a direct single-transaction wallet mutation, so there is no separate cleanup command for reserved local workflow state.",
+                next: "Retry with `cogcoin anchor <domain>` or inspect the domain with `cogcoin show <domain>`.",
+            };
+        }
+        if (errorCode === "cli_wallet_export_removed") {
+            return {
+                what: "`wallet export` is no longer available.",
+                why: "Portable encrypted wallet archives were removed from the client, so wallet state is no longer exported through a `.cogcoin` archive file.",
+                next: "Use the wallet mnemonic as the supported recovery path, or retry with another wallet command.",
+            };
+        }
+        if (errorCode === "cli_wallet_import_removed") {
+            return {
+                what: "`wallet import` is no longer available.",
+                why: "Portable encrypted wallet archives were removed from the client, so this version no longer imports wallet state from archive files.",
+                next: "Use `cogcoin init`, choose \"Restore existing wallet\", and enter the recovery mnemonic instead.",
+            };
+        }
+        if (errorCode === "cli_field_create_initial_value_not_supported") {
+            return {
+                what: "`field create` no longer accepts an initial value.",
+                why: "Field creation is now always a single FIELD_REG transaction. Any field value must be written afterward with a separate `field set` command.",
+                next: "Create the field first, then run `cogcoin field set <domain> <field> ...`.",
+            };
+        }
+        return null;
+    },
+];

package/dist/cli/output/rules/generic.d.ts

@@ -0,0 +1,2 @@
+import type { CliErrorPresentationRule } from "../types.js";
+export declare const genericCliErrorRules: readonly CliErrorPresentationRule[];

package/dist/cli/output/rules/generic.js

@@ -0,0 +1,13 @@
+import { isBlockedError } from "../classify.js";
+export const genericCliErrorRules = [
+    ({ errorCode, fallbackMessage }) => {
+        if (!isBlockedError(errorCode)) {
+            return null;
+        }
+        return {
+            what: fallbackMessage,
+            why: "The command was blocked by the current local wallet or service state.",
+            next: "Review `cogcoin status` and retry after the blocking condition is cleared.",
+        };
+    },
+];

package/dist/cli/output/rules/index.d.ts

@@ -0,0 +1,2 @@
+import type { CliErrorPresentation } from "../types.js";
+export declare function createCliErrorPresentation(errorCode: string, fallbackMessage: string, error?: unknown): CliErrorPresentation | null;

package/dist/cli/output/rules/index.js

@@ -0,0 +1,24 @@
+import { cliSurfaceErrorRules } from "./cli-surface.js";
+import { genericCliErrorRules } from "./generic.js";
+import { miningAndUpdateErrorRules } from "./mining-update.js";
+import { serviceErrorRules } from "./services.js";
+import { walletAdminErrorRules } from "./wallet-admin.js";
+import { walletMutationErrorRules } from "./wallet-mutations.js";
+const cliErrorPresentationRules = [
+    ...walletAdminErrorRules,
+    ...cliSurfaceErrorRules,
+    ...miningAndUpdateErrorRules,
+    ...serviceErrorRules,
+    ...walletMutationErrorRules,
+    ...genericCliErrorRules,
+];
+export function createCliErrorPresentation(errorCode, fallbackMessage, error) {
+    const input = { errorCode, fallbackMessage, error };
+    for (const rule of cliErrorPresentationRules) {
+        const presentation = rule(input);
+        if (presentation !== null) {
+            return presentation;
+        }
+    }
+    return null;
+}

package/dist/cli/output/rules/mining-update.d.ts

@@ -0,0 +1,2 @@
+import type { CliErrorPresentationRule } from "../types.js";
+export declare const miningAndUpdateErrorRules: readonly CliErrorPresentationRule[];

package/dist/cli/output/rules/mining-update.js

@@ -0,0 +1,68 @@
+export const miningAndUpdateErrorRules = [
+    ({ errorCode }) => {
+        if (errorCode === "mining_setup_invalid_provider") {
+            return {
+                what: "Mining provider choice is invalid.",
+                why: "Built-in mining setup currently supports only `openai` or `anthropic` as the provider selection.",
+                next: "Rerun `cogcoin mine setup` and choose either `openai` or `anthropic`.",
+            };
+        }
+        if (errorCode === "mining_setup_missing_api_key") {
+            return {
+                what: "Mining provider API key is required.",
+                why: "Built-in mining setup cannot save provider configuration without a non-empty API key.",
+                next: "Rerun `cogcoin mine setup` and enter the provider API key when prompted.",
+            };
+        }
+        if (errorCode === "mining_setup_missing_model_id") {
+            return {
+                what: "Mining model ID is required.",
+                why: "Built-in mining setup cannot save a custom mining model choice unless it has a non-empty model ID.",
+                next: "Rerun `cogcoin mine setup`, choose `Custom model ID...`, and enter the model ID when prompted.",
+            };
+        }
+        if (errorCode === "mining_setup_canceled") {
+            return {
+                what: "Mining setup was canceled.",
+                why: "The interactive mining-model selection was canceled before any provider configuration was saved.",
+                next: "Rerun `cogcoin mine setup` when you are ready to choose a provider model.",
+            };
+        }
+        if (errorCode === "mine_prompt_domain_not_mineable") {
+            return {
+                what: "A new mining prompt override can only target a mineable anchored root domain.",
+                why: "Cogcoin only creates new domain prompt overrides for locally controlled anchored root domains that are currently mineable. Existing stored prompt entries can still be edited or cleared by name even when they are dormant.",
+                next: "Run `cogcoin domains --mineable` to see eligible domains, or rerun `cogcoin mine prompt <domain>` for an existing stored prompt entry.",
+            };
+        }
+        if (errorCode === "cli_update_requires_tty") {
+            return {
+                what: "Updating Cogcoin needs an interactive terminal or `--yes`.",
+                why: "When a newer client release is available, `cogcoin update` prompts before running the global npm install unless `--yes` is provided.",
+                next: "Rerun `cogcoin update` in an interactive terminal, or add `--yes` to apply the update non-interactively.",
+            };
+        }
+        if (errorCode === "cli_update_registry_unavailable") {
+            return {
+                what: "Cogcoin could not read the latest client version from the npm registry.",
+                why: "The explicit update command requires a fresh registry lookup before it can compare versions or run the install.",
+                next: "Check network access and rerun `cogcoin update`.",
+            };
+        }
+        if (errorCode === "cli_update_npm_not_found") {
+            return {
+                what: "Cogcoin could not find npm to install the update.",
+                why: "The update command runs `npm install -g @cogcoin/client`, and no usable `npm` executable was available on PATH.",
+                next: "Install Node.js/npm or fix PATH, then rerun `cogcoin update`.",
+            };
+        }
+        if (errorCode === "cli_update_install_failed") {
+            return {
+                what: "Cogcoin update installation failed.",
+                why: "The global npm install exited unsuccessfully before the client update completed.",
+                next: "Review the npm output above, fix the installation issue, then rerun `cogcoin update`.",
+            };
+        }
+        return null;
+    },
+];

package/dist/cli/output/rules/services.d.ts

@@ -0,0 +1,2 @@
+import type { CliErrorPresentationRule } from "../types.js";
+export declare const serviceErrorRules: readonly CliErrorPresentationRule[];

package/dist/cli/output/rules/services.js

@@ -0,0 +1,110 @@
+export const serviceErrorRules = [
+    ({ errorCode }) => {
+        if (errorCode.endsWith("_requires_tty") && errorCode !== "cli_update_requires_tty") {
+            return {
+                what: "Interactive terminal input is required.",
+                why: "This command needs terminal input before it can continue safely.",
+                next: "Rerun the command in an interactive terminal.",
+            };
+        }
+        if (errorCode.includes("tip_mismatch") || errorCode.includes("stale") || errorCode.includes("catching_up") || errorCode.includes("starting")) {
+            return {
+                what: "Trusted service state is not ready.",
+                why: "The wallet, bitcoind, or indexer is not yet aligned closely enough for this command to proceed safely.",
+                next: "Check `cogcoin status`, wait for services to settle, and retry. If the state stays degraded, run `cogcoin repair`.",
+            };
+        }
+        if (errorCode === "indexer_daemon_background_follow_recovery_failed") {
+            return {
+                what: "The managed indexer daemon could not recover automatic background follow.",
+                why: "Cogcoin tried to resume or restart the compatible managed indexer daemon, but it still failed to enter background follow.",
+                next: "Run `cogcoin repair` if this persists, then retry.",
+            };
+        }
+        if (errorCode === "indexer_daemon_service_version_mismatch") {
+            return {
+                what: "The live indexer daemon is running an incompatible service API version.",
+                why: "This wallet only trusts indexer daemons that speak `cogcoin/indexer-ipc/v1`, and the reachable daemon reported a different API version.",
+                next: "Run `cogcoin repair` so the wallet can stop the incompatible daemon and restart a compatible managed indexer service.",
+            };
+        }
+        if (errorCode === "indexer_daemon_wallet_root_mismatch") {
+            return {
+                what: "The live indexer daemon belongs to a different wallet root.",
+                why: "Managed indexer daemons are namespaced per wallet root, and the reachable daemon reported a different wallet root than this local wallet.",
+                next: "Run `cogcoin repair` so the wallet can stop the conflicting managed daemon and restore the correct local indexer service.",
+            };
+        }
+        if (errorCode === "indexer_daemon_schema_mismatch") {
+            return {
+                what: "The live indexer daemon is using an incompatible sqlite schema.",
+                why: "This wallet only trusts indexer daemons with the expected sqlite schema contract, and the reachable daemon reported a schema mismatch.",
+                next: "Run `cogcoin repair` after stopping the incompatible daemon, then retry.",
+            };
+        }
+        if (errorCode === "indexer_daemon_protocol_error") {
+            return {
+                what: "The live indexer daemon socket is not speaking the expected protocol.",
+                why: "A process is bound to the managed indexer socket, but it did not respond with a valid cogcoin indexer IPC status exchange.",
+                next: "Run `cogcoin repair` to clear stale managed indexer artifacts and restore a compatible daemon.",
+            };
+        }
+        if (errorCode === "managed_bitcoind_service_version_mismatch" || errorCode.includes("bitcoind_service_version_mismatch")) {
+            return {
+                what: "The live managed bitcoind service is running an incompatible service version.",
+                why: "This wallet only trusts managed bitcoind services that speak `cogcoin/bitcoind-service/v1`, and the reachable service reported a different runtime contract.",
+                next: "Run `cogcoin repair` so the wallet can stop the incompatible managed bitcoind service and restart a compatible one.",
+            };
+        }
+        if (errorCode === "managed_bitcoind_wallet_root_mismatch" || errorCode.includes("bitcoind_wallet_root_mismatch")) {
+            return {
+                what: "The live managed bitcoind service belongs to a different wallet root.",
+                why: "Managed bitcoind services are tied to one wallet root, and the reachable service reported a different wallet root than this local wallet expects.",
+                next: "Run `cogcoin repair` so the wallet can stop the conflicting managed bitcoind service and restore the correct one.",
+            };
+        }
+        if (errorCode === "managed_bitcoind_runtime_mismatch" || errorCode.includes("bitcoind_runtime_mismatch")) {
+            return {
+                what: "The live managed bitcoind service runtime does not match this wallet.",
+                why: "The reachable service is using a different chain, data directory, or runtime root than this wallet expects, so its status cannot be trusted here.",
+                next: "Run `cogcoin repair` so the wallet can clear the conflicting runtime and restart a compatible managed bitcoind service.",
+            };
+        }
+        if (errorCode.includes("bitcoind_replica_missing")) {
+            return {
+                what: "The managed Core wallet replica is missing.",
+                why: "This wallet needs a matching managed Core descriptor-wallet replica before it can safely perform stateful operations.",
+                next: "Run `cogcoin repair` to recreate the managed Core wallet replica, then retry.",
+            };
+        }
+        if (errorCode.includes("bitcoind_replica_mismatch")) {
+            return {
+                what: "The managed Core wallet replica does not match trusted wallet state.",
+                why: "The local wallet state and the managed Core replica disagree, so this command refuses to keep going on untrusted Core metadata.",
+                next: "Run `cogcoin repair` to recreate or rebind the managed Core wallet replica, then retry.",
+            };
+        }
+        if (errorCode === "mining_preemption_timeout") {
+            return {
+                what: "Wallet repair is blocked by active mining work.",
+                why: "Repair waits for mining generation work to acknowledge preemption before it mutates local indexer runtime artifacts.",
+                next: "Pause or stop mining, then rerun `cogcoin repair`.",
+            };
+        }
+        if (errorCode.includes("paused")) {
+            return {
+                what: "Work is currently paused.",
+                why: "Another wallet or mining workflow has priority right now.",
+                next: "Wait for the current work to settle, then rerun the command.",
+            };
+        }
+        if (errorCode.includes("setup") || errorCode.includes("validation") || errorCode.includes("core_replica_not_ready")) {
+            return {
+                what: "Local setup is incomplete.",
+                why: "This command depends on a local component that is not ready yet.",
+                next: "Review the local status output, finish the required setup or repair step, and retry.",
+            };
+        }
+        return null;
+    },
+];

package/dist/cli/output/rules/wallet-admin.d.ts

@@ -0,0 +1,2 @@
+import type { CliErrorPresentationRule } from "../types.js";
+export declare const walletAdminErrorRules: readonly CliErrorPresentationRule[];