@solard/cli 0.2.17 → 0.2.20

package/src/index.ts

@@ -122,7 +122,7 @@ function friendlyCliError(error: unknown): string | null {
   if (code === "MISSING_CONFIG" && error.message.includes("SLRD_MASTER_KEY")) {
     return `${error.message}\n\nEnter the wallet password interactively, or set SLRD_MASTER_KEY for automation/CI.`;
   }
-  return null;
+  return error.message.trim() || error.name;
 }
 function duration(value: string | undefined, fallbackMs: number): number {
   if (!value) return fallbackMs;
@@ -279,6 +279,8 @@ function commandNeedsSigningVault(
     if (values[0] === "resume") return true;
     return flags.has("live");
   }
+  if (command === "reclaim") return flags.has("live") || flags.has("simulate");
+  if (command === "unwrap" && values[0] === "wsol") return true;
   if (
     [
       "import",
@@ -317,12 +319,21 @@ function commandNeedsSigningVault(
       "spam-buy",
       "buy-spam",
       "run",
+      "strategy",
     ].includes(command)
   )
     return true;
   return false;
 }
 
+function sweepUsage(): string {
+  return (
+    "Usage: slrd sweep --to <contact|wallet|address> --below <SOL> " +
+    "[--wallets <a,b,...>] [--keep <wallet=SOL,...>] [--simulate | --live] [--json]\n" +
+    "Compatibility: slrd sweep sol --to <destination> --max-balance-sol <SOL>"
+  );
+}
+
 async function storedWalletCount(): Promise<number> {
   const { createTraderSolard } = await import("@solard/core");
   const probe = createTraderSolard();
@@ -355,7 +366,9 @@ External contacts (public addresses only; never signing wallets or group members
   slrd token <token_ca> [name] [--metadata-json <json>]
   slrd token set <token|ca> [--pool <address>] [--quote-mint <mint>] [--quote-program <program>] [--metadata-json <json>]
   slrd token refresh <token|ca>
-  slrd token backfill <ca> [--replace] [--confirmed] [--batch-size 100] [--rpc-concurrency 3] [--max-signatures N] [--json]
+  slrd token backfill <ca> [--max-signatures N] [--json]  Index signatures only; no transaction hydration by default
+  slrd token backfill <ca> --materialize [--price-sample-ms 1000] [--replace] [--rpc-concurrency 2]
+  slrd token backfill <ca> --exact [--replace] [--rpc-concurrency 2]
                                                         Durable exact trades + sparse 1s candle materialization from creation
   slrd token trades <ca> [--from-start] [--min-sol N] [--owner <wallet>] [--side buy|sell] [--limit N] [--json]
   slrd token analyze <ca> [--top N] [--json]
@@ -372,8 +385,18 @@ Vanity mints
   slrd vanity pool release <mint-address>               Release an ambiguous/failed launch reservation
   launch/vamp: add --mint-pool pump [--mint-pool-address <address>] to consume a pooled mint
 
-Pump pairs
+Shared market feed
+  slrd feed serve [--host 127.0.0.1] [--port 8788] [--rpc-rps 5] [--rpc-read-rps 2] [--max-fallback-subs 200]
+                                                        One upstream Pump/PumpSwap/LaunchLab feed shared by watchers, agents, and future UI clients
+
+Launch discovery
+  slrd launch watch [--venue pump,raydium-launchlab] [--min-mcap 5000] [--ath-step-pct 20] [--track-ttl 30m] [--feed ws://127.0.0.1:8788/ws] [--show-new] [--prices] [--json]
+                                                        Consume the shared feed; ignore Pump Mayhem and notify on first $5k cross and each +20% notified ATH step
+
+Pump discovery
   slrd pump pairs [--json]                              Read Pump-supported quote mints from the on-chain Global account
+  slrd pump watch [--min-mcap 5000] [--ath-step-pct 20] [--track-ttl 30m] [--feed ws://127.0.0.1:8788/ws] [--show-new] [--prices] [--json]
+                                                        Compatibility alias for: slrd launch watch --venue pump
 
 Metadata and launching
   slrd launch pump --creator <wallet> (--uri <metadata_uri> | --metadata <json> | --image <path> --description <text>) [--pair SOL|USDC|<custom-quote-mint>] [--beneficiary <wallet|address>] [--alias <name>] [--live] [--skip-simulation]
@@ -401,11 +424,12 @@ Backtesting
 Transfers and consolidation
   slrd transfer <contact|wallet|address> --wallet <source-wallet> --sol <amount> [--simulate-only]
   slrd transfer <contact|wallet|address> --wallet <source-wallet> --token <USDC|mint> --amount <ui> [--simulate-only]
-  slrd sweep sol --to <contact|wallet|address> [--wallets <a,b,...>] [--max-balance-sol <SOL>] [--exclude-group <group>] [--exclude-prefix <prefix>] [--keep <wallet=SOL,...>] [--keep-if-tokens <SOL> | --keep-if-token <token>=<SOL>] [--simulate | --live] [--json]
-                                                        Without --wallets, sweep considers all stored signing wallets
+  slrd sweep --to <contact|wallet|address> --below <SOL> [--wallets <a,b,...>] [--keep <wallet=SOL,...>] [--simulate | --live] [--json]
+                                                        Sweeps stored wallets strictly below the threshold; preview is the default
+  slrd sweep sol ...                                    Compatibility alias; --max-balance-sol remains accepted
 
 Token liquidation
-  slrd liquidate tokens [--except <token|mint>] [--wallets <a,b,...>] [--except-wallet <wallet>] [--except-wallets <a,b,...>] [--slippage-bps 1500] [--no-jupiter] [--burn-unsellable] [--simulate | --live]
+  slrd liquidate tokens [--except <token|mint>] [--wallets <a,b,...>] [--except-wallet <wallet>] [--except-wallets <a,b,...>] [--slippage-bps 1500] [--no-jupiter] [--burn-unsellable] [--rounds 3] [--simulate | --live]
                                                         Sell all supported tokens unless protected with --except; excluded wallets are not scanned or touched
 
 RPC
@@ -426,7 +450,12 @@ Trading
   slrd buy <future-mint> (--wallet <wallet> | --group <name>) (--sol <amount> | --lamports <amount> | --min-bps <n> --max-bps <n>) --spam [--live]
   slrd spam-buy [pump] <future-mint> (--wallet <wallet> | --group <name>) (--sol <amount> | --lamports <amount> | --min-bps <n> --max-bps <n>) [--sender <id>] [--live]
   slrd sell <token|ca> (--wallet <wallet> | --wallets <w1,w2> | --group <name>) [--bps 10000] [--venue auto|native|jupiter] [--slippage-bps 1500] [--sender rpc|helius|jito] [--simulate-only]
-  slrd unwrap-wsol (--wallet <wallet> | --wallets <w1,w2> | --group <name>) [--sender rpc|helius|jito] [--ignore-missing] [--continue-on-error] [--simulate-only]
+  slrd unwrap-wsol (--all-wallets | --wallet <wallet> | --wallets <w1,w2> | --group <name>) [--sender rpc|helius|jito] [--ignore-missing] [--simulate-only]
+                                                        Close every owned WSOL token account, including non-ATA WSOL accounts
+  slrd reclaim inspect --all-wallets                    List Loader-v3 buffers/programs controlled by stored wallets
+  slrd reclaim buffers --all-wallets [--simulate | --live]
+  slrd reclaim programs --all-wallets [--simulate | --live --confirm-program-close]
+  slrd reclaim all --all-wallets [--simulate | --live --confirm-program-close]
   slrd claim <token|ca> --wallet <wallet> [--sender rpc|helius|jito]
   slrd transfer-many --wallet <wallet> (--token <mint>|--sol) --file <allocations.json> [--id <stable-id> --live]
   slrd transfer-many status <stable-id>
@@ -441,10 +470,14 @@ Trading
   slrd rewards claim <token|ca> --wallet <fee-payer> [--id <stable-claim-id> --basis <reward-basis.json>]
   slrd rewards claim-status <stable-claim-id>
 
-Scripts (strategies stay outside the kernel)
+Scripts and event strategies
   slrd scripts                              List scripts registered in slrd.config.ts
   slrd run <name-or-path> [script flags...] Execute a script that imports slrd
   slrd run snipe --name <exact_name> --group <group> --sol 0.05 --sender jito
+  slrd strategy run <file.ts> --token <mint|alias> --wallet <wallet> [--params <json>] [--feed ws://127.0.0.1:8788/ws] [--live]
+                                                        Run an onPrice strategy from the shared feed; wallet/execution state remains isolated per agent
+  slrd strategy backtest <file.ts> --token <mint> [--params <json>] [--capital-sol 1] [--price-sample 5s] [--sol-usd N] [--json]
+                                                        Replay the same strategy file over durable token history
 
 Meteora DLMM
   slrd meteora discover --timeframe 30m --sort fee-active-tvl --limit 20
@@ -481,6 +514,9 @@ Watching
   slrd watch list
 
 Transactions and ALTs
+  slrd tx stream --wallet <wallet|address> [--finalized] [--jsonl]
+  slrd tx stream --wallets <a,b,c> [--finalized] [--jsonl]
+                                                        Stream every transaction mentioning the selected wallets until Ctrl+C
   slrd history
   slrd jito tip-accounts [--endpoint <block-engine-url>]
   slrd alt add <address> [label]
@@ -782,6 +818,24 @@ async function main() {
     process.exitCode = await runScript(script, scriptArgs);
     return;
   }
+  if (command === "feed" && values[0] === "serve") {
+    const { runPriceFeedServerCommand } =
+      await import("./price-feed-server.ts");
+    await runPriceFeedServerCommand({ flags, emit });
+    return;
+  }
+  if (command === "strategy" && values[0] === "backtest") {
+    const { runStrategyBacktestCommand } =
+      await import("./strategy-backtest-command.ts");
+    await runStrategyBacktestCommand({ values, flags, emit });
+    return;
+  }
+  if (command === "strategy" && values[0] === "run") {
+    const { runTradeStrategyCommand } =
+      await import("./trade-strategy-command.ts");
+    await runTradeStrategyCommand({ values, flags, emit });
+    return;
+  }
   if (
     (command === "prepare" && values[0] === "pump") ||
     (command === "launch" &&
@@ -794,6 +848,11 @@ async function main() {
     await runPumpExternalDeploymentFromArgs(externalArgs);
     return;
   }
+  if (command === "launch" && values[0] === "watch") {
+    const { runLaunchWatchCommand } = await import("./launch-watch-command.ts");
+    await runLaunchWatchCommand({ flags, emit });
+    return;
+  }
   if (
     command === "launch" &&
     (values[0] === "pump" || values[0] === "pump-token")
@@ -822,6 +881,11 @@ async function main() {
     });
     return;
   }
+  if (command === "pump" && values[0] === "watch") {
+    const { runPumpWatchCommand } = await import("./pump-watch-command.ts");
+    await runPumpWatchCommand({ flags, emit });
+    return;
+  }
   if (command === "jito" && values[0] === "tip-accounts") {
     const endpoint = (
       flags.get("endpoint") ??
@@ -870,6 +934,12 @@ async function main() {
       return;
     }
 
+    if (command === "reclaim") {
+      const { runReclaimCommand } = await import("./reclaim-command.ts");
+      await runReclaimCommand({ slrd, values, flags, emit });
+      return;
+    }
+
     if (command === "meteora") {
       await handleMeteoraCommand({ slrd, values, flags, emit });
       return;
@@ -1303,7 +1373,7 @@ async function main() {
         try {
           const tx = await connection.getTransaction(entry.signature, {
             commitment: "confirmed",
-            maxSupportedTransactionVersion: 0,
+            maxSupportedTransactionVersion: 1,
           });
           const fee = tx?.meta?.fee;
           const payer = txAccountKeys(tx)[0] ?? "";
@@ -1367,6 +1437,328 @@ async function main() {
         );
       return;
     }
+    if (command === "tx" && values[0] === "stream") {
+      const walletFlag = flags.get("wallet");
+      const walletRefs = [
+        ...(walletFlag && walletFlag !== "true" ? [walletFlag] : []),
+        ...csv(flags.get("wallets")),
+      ];
+      if (walletRefs.length === 0) {
+        throw new Error(
+          "Usage: slrd tx stream --wallet <wallet|address> | --wallets <a,b,c> [--finalized] [--jsonl]",
+        );
+      }
+
+      const { PublicKey } = await import("@solana/web3.js");
+      const connection = slrd.connection();
+      const commitment = flags.has("finalized") ? "finalized" : "confirmed";
+      const enrichAttempts = Math.max(
+        1,
+        Math.min(20, Math.trunc(int(flags, "enrich-attempts", 8) ?? 8)),
+      );
+      const enrichDelayMs = Math.max(
+        50,
+        Math.trunc(int(flags, "enrich-delay-ms", 250) ?? 250),
+      );
+
+      type StreamWallet = {
+        ref: string;
+        name: string | null;
+        address: string;
+        publicKey: InstanceType<typeof PublicKey>;
+      };
+
+      const byAddress = new Map<string, StreamWallet>();
+      for (const ref of walletRefs) {
+        let name: string | null = null;
+        let publicKey: InstanceType<typeof PublicKey>;
+        try {
+          const resolved = slrd.resolveWallet(ref);
+          publicKey = resolved.address;
+          name = resolved.row?.name ?? null;
+        } catch {
+          try {
+            publicKey = new PublicKey(ref);
+          } catch {
+            throw new Error(`Unknown wallet or invalid Solana address: ${ref}`);
+          }
+        }
+        const address = publicKey.toBase58();
+        if (!byAddress.has(address)) {
+          byAddress.set(address, { ref, name, address, publicKey });
+        }
+      }
+      const watched = [...byAddress.values()];
+      const watchedAddresses = new Set(watched.map((row) => row.address));
+      const labelFor = (row: StreamWallet) =>
+        row.name ? `@${row.name}` : shortKey(row.address);
+
+      type PendingSignature = {
+        signature: string;
+        observedSlot: number | null;
+      };
+
+      const queue: PendingSignature[] = [];
+      const queued = new Set<string>();
+      const seen = new Set<string>();
+      const seenOrder: string[] = [];
+      const listenerIds: number[] = [];
+      let processing = false;
+      let stopped = false;
+      let stopResolve: (() => void) | null = null;
+
+      const rememberSeen = (signature: string) => {
+        if (seen.has(signature)) return;
+        seen.add(signature);
+        seenOrder.push(signature);
+        while (seenOrder.length > 20_000) {
+          const oldest = seenOrder.shift();
+          if (oldest) seen.delete(oldest);
+        }
+      };
+
+      const transactionWithRetry = async (signature: string) => {
+        for (let attempt = 1; attempt <= enrichAttempts; attempt += 1) {
+          const tx = await connection.getTransaction(signature, {
+            commitment,
+            maxSupportedTransactionVersion: 1,
+          });
+          if (tx) return tx;
+          if (attempt < enrichAttempts) {
+            await new Promise((resolve) => setTimeout(resolve, enrichDelayMs));
+          }
+        }
+        return null;
+      };
+
+      const printTransaction = async (
+        item: PendingSignature,
+      ): Promise<void> => {
+        const tx = await transactionWithRetry(item.signature);
+        if (!tx?.meta) {
+          const unavailable = {
+            type: "transaction",
+            signature: item.signature,
+            slot: item.observedSlot,
+            commitment,
+            status: "unavailable",
+            wallets: [],
+          };
+          if (flags.has("jsonl")) emit(JSON.stringify(unavailable) + "\n");
+          else
+            emit(
+              `${new Date().toISOString()}  UNAVAILABLE  ${item.signature}  slot=${item.observedSlot ?? "?"}\n`,
+            );
+          return;
+        }
+
+        const keys = txAccountKeys(tx);
+        const keySet = new Set(keys);
+        const touched = watched.filter((row) => keySet.has(row.address));
+        if (touched.length === 0) return;
+
+        const feeLamports =
+          typeof tx.meta.fee === "number" && Number.isFinite(tx.meta.fee)
+            ? BigInt(Math.trunc(tx.meta.fee))
+            : 0n;
+        const payer = keys[0] ?? null;
+        const status = tx.meta.err ? "failed" : "confirmed";
+        const at =
+          tx.blockTime == null
+            ? new Date().toISOString()
+            : new Date(tx.blockTime * 1_000).toISOString();
+
+        const walletRows = touched.map((wallet) => {
+          const walletIndex = keys.indexOf(wallet.address);
+          let nativeDeltaLamports: bigint | null = null;
+          if (
+            walletIndex >= 0 &&
+            typeof tx.meta!.preBalances?.[walletIndex] === "number" &&
+            typeof tx.meta!.postBalances?.[walletIndex] === "number"
+          ) {
+            nativeDeltaLamports =
+              BigInt(Math.trunc(tx.meta!.postBalances[walletIndex]!)) -
+              BigInt(Math.trunc(tx.meta!.preBalances[walletIndex]!));
+          }
+
+          const tokenDeltas = [...txWalletTokenBalances(tx, wallet.address)]
+            .map(([mint, balance]) => ({
+              mint,
+              decimals: balance.decimals,
+              deltaRaw: balance.post - balance.pre,
+            }))
+            .filter((row) => row.deltaRaw !== 0n)
+            .sort((left, right) => {
+              const leftAbs =
+                left.deltaRaw < 0n ? -left.deltaRaw : left.deltaRaw;
+              const rightAbs =
+                right.deltaRaw < 0n ? -right.deltaRaw : right.deltaRaw;
+              return leftAbs === rightAbs
+                ? left.mint.localeCompare(right.mint)
+                : leftAbs > rightAbs
+                  ? -1
+                  : 1;
+            });
+
+          return {
+            ref: wallet.ref,
+            name: wallet.name,
+            address: wallet.address,
+            nativeDeltaLamports,
+            feePaidLamports: payer === wallet.address ? feeLamports : 0n,
+            tokenDeltas,
+          };
+        });
+
+        if (flags.has("jsonl")) {
+          emit(
+            JSON.stringify(
+              {
+                type: "transaction",
+                at,
+                signature: item.signature,
+                slot: tx.slot ?? item.observedSlot,
+                commitment,
+                status,
+                error: tx.meta.err ?? null,
+                feeLamports,
+                feePayer: payer,
+                wallets: walletRows,
+              },
+              (_, value) =>
+                typeof value === "bigint" ? value.toString() : value,
+            ) + "\n",
+          );
+          return;
+        }
+
+        emit(
+          `\n${at}  ${status.toUpperCase()}  slot=${tx.slot ?? item.observedSlot ?? "?"}\n` +
+            `SIG  ${item.signature}\n` +
+            `FEE  ${formatRaw(feeLamports, 9)} SOL  payer=${payer ?? "?"}\n`,
+        );
+
+        for (const row of walletRows) {
+          const wallet = byAddress.get(row.address)!;
+          emit(`  ${labelFor(wallet)}  ${row.address}\n`);
+          emit(
+            `    SOL    ${
+              row.nativeDeltaLamports == null
+                ? "n/a"
+                : `${formatSignedRaw(row.nativeDeltaLamports, 9)} SOL`
+            }${
+              row.feePaidLamports > 0n
+                ? `  (paid fee ${formatRaw(row.feePaidLamports, 9)} SOL)`
+                : ""
+            }\n`,
+          );
+          if (row.tokenDeltas.length === 0) {
+            emit("    TOKEN  no wallet-owned SPL balance delta\n");
+          } else {
+            for (const delta of row.tokenDeltas) {
+              const tokenLabel =
+                delta.mint === NATIVE_SOL_MINT
+                  ? "WSOL"
+                  : delta.mint === CANONICAL_USDC_MINT
+                    ? "USDC"
+                    : shortKey(delta.mint);
+              emit(
+                `    TOKEN  ${formatSignedRaw(delta.deltaRaw, delta.decimals)} ${tokenLabel}  ${delta.mint}\n`,
+              );
+            }
+          }
+        }
+
+        if (tx.meta.err) {
+          emit(`  ERROR  ${JSON.stringify(tx.meta.err)}\n`);
+        }
+      };
+
+      const drain = async (): Promise<void> => {
+        if (processing) return;
+        processing = true;
+        try {
+          while (!stopped && queue.length > 0) {
+            const item = queue.shift()!;
+            queued.delete(item.signature);
+            if (seen.has(item.signature)) continue;
+            try {
+              await printTransaction(item);
+            } catch (error) {
+              const message =
+                error instanceof Error ? error.message : String(error);
+              if (flags.has("jsonl")) {
+                emit(
+                  JSON.stringify({
+                    type: "stream-error",
+                    signature: item.signature,
+                    error: message,
+                  }) + "\n",
+                );
+              } else {
+                process.stderr.write(
+                  `${OWL} tx stream ${item.signature}: ${message}\n`,
+                );
+              }
+            } finally {
+              rememberSeen(item.signature);
+            }
+          }
+        } finally {
+          processing = false;
+          if (!stopped && queue.length > 0) void drain();
+        }
+      };
+
+      const enqueue = (signature: string, observedSlot: number | null) => {
+        if (stopped || seen.has(signature) || queued.has(signature)) return;
+        queued.add(signature);
+        queue.push({ signature, observedSlot });
+        void drain();
+      };
+
+      if (!flags.has("jsonl")) {
+        emit(
+          `TX STREAM  wallets=${watched.length}  commitment=${commitment}  Ctrl+C to stop\n`,
+        );
+        for (const wallet of watched) {
+          emit(`  ${labelFor(wallet)}  ${wallet.address}\n`);
+        }
+        emit("\n");
+      }
+
+      for (const wallet of watched) {
+        const id = connection.onLogs(
+          wallet.publicKey,
+          (logs, context) => {
+            // Stream failed transactions too. The transaction metadata below
+            // is the authoritative status/error source.
+            enqueue(logs.signature, context?.slot ?? null);
+          },
+          commitment,
+        );
+        listenerIds.push(id);
+      }
+
+      await new Promise<void>((resolve) => {
+        stopResolve = resolve;
+        const stop = () => {
+          if (stopped) return;
+          stopped = true;
+          resolve();
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+      });
+
+      await Promise.allSettled(
+        listenerIds.map((id) => connection.removeOnLogsListener(id)),
+      );
+
+      if (!flags.has("jsonl")) emit("TX STREAM STOPPED\n");
+      return;
+    }
+
     if (command === "sol-flow" || (command === "tx" && values[0] === "flow")) {
       const walletRef = need(flags, "wallet");
       const wallet = slrd.resolveWallet(walletRef);
@@ -1418,7 +1810,7 @@ async function main() {
         try {
           const tx = await connection.getTransaction(entry.signature, {
             commitment: "confirmed",
-            maxSupportedTransactionVersion: 0,
+            maxSupportedTransactionVersion: 1,
           });
           if (!tx?.meta) {
             rows.push({
@@ -1894,7 +2286,6 @@ async function main() {
         : flags.has("simulate")
           ? "SIMULATE"
           : "PLAN";
-
       emit(`LIQUIDATE ${mode}\n`);
       for (const ref of except) {
         const mint = resolveTokenMintForPolicy(slrd, ref);
@@ -1960,6 +2351,15 @@ async function main() {
             emit(
               `ROUTE    ${event.index}/${event.total}  ${shortKey(event.mint)}\n`,
             );
+          } else if (event.stage === "consolidation-start") {
+            showAction("MOVE", event.index, event.total, event.action);
+            emit(
+              `         consolidate ${event.accounts} non-ATA account(s), raw=${event.amountRaw.toString()} -> ATA\n`,
+            );
+          } else if (event.stage === "consolidation-done") {
+            emit(
+              `MOVED    ${event.index}/${event.total}  @${event.action.walletName}  ${shortKey(event.action.mint)}  accounts=${event.accounts} signatures=${event.signatures.length}\n`,
+            );
           } else if (event.stage === "action-start") {
             showAction(
               flags.has("simulate") ? "SIM " : "DO  ",
@@ -1983,12 +2383,19 @@ async function main() {
         },
       };
 
-      const plan = await planRegistryTokenLiquidation(slrd, options);
-      emit(
-        `PLAN     native=${plan.totals.sell}  jupiter=${plan.totals.jupiterSell}  ` +
-          `unwrap=${plan.totals.unwrapWsol}  close-empty-now=${plan.totals.closeEmpty}  ` +
-          `keep=${plan.totals.keepProtected}  unsupported=${plan.totals.skipUnsupported}\n`,
-      );
+      const emitPlan = (
+        plan: Awaited<ReturnType<typeof planRegistryTokenLiquidation>>,
+        prefix = "PLAN    ",
+      ) => {
+        emit(
+          `${prefix} native=${plan.totals.sell}  jupiter=${plan.totals.jupiterSell}  ` +
+            `unwrap=${plan.totals.unwrapWsol}  close-empty-now=${plan.totals.closeEmpty}  ` +
+            `keep=${plan.totals.keepProtected}  unsupported=${plan.totals.skipUnsupported}\n`,
+        );
+      };
+
+      let plan = await planRegistryTokenLiquidation(slrd, options);
+      emitPlan(plan);
 
       if (!flags.has("simulate") && !flags.has("live")) {
         const actionable = plan.actions.filter(
@@ -2043,9 +2450,43 @@ async function main() {
         return;
       }
 
-      const results = flags.has("simulate")
-        ? await simulateRegistryTokenLiquidation(slrd, plan, options)
-        : await executeRegistryTokenLiquidation(slrd, plan, options);
+      let results: Awaited<ReturnType<typeof executeRegistryTokenLiquidation>> =
+        [];
+      let finalPlan = plan;
+
+      if (flags.has("simulate")) {
+        results = await simulateRegistryTokenLiquidation(slrd, plan, options);
+      } else {
+        const maxRounds = Math.max(
+          1,
+          Math.min(6, int(flags, "rounds", 3) ?? 3),
+        );
+        for (let round = 1; round <= maxRounds; round += 1) {
+          if (round > 1) {
+            emit(`RESCAN   liquidation round ${round}/${maxRounds}\n`);
+            emitPlan(plan, "PLAN-R  ");
+          }
+          results.push(
+            ...(await executeRegistryTokenLiquidation(slrd, plan, options)),
+          );
+          finalPlan = await planRegistryTokenLiquidation(slrd, options);
+          const retryable = finalPlan.actions.filter(
+            (action) =>
+              action.amountRaw > 0n &&
+              (action.kind === "sell" ||
+                action.kind === "jupiter-sell" ||
+                action.kind === "unwrap-wsol" ||
+                (options.burnUnsellable && action.kind === "skip-unsupported")),
+          );
+          if (!retryable.length) break;
+          if (round < maxRounds) {
+            emit(
+              `RESIDUAL ${retryable.length} positive holding(s) appeared/remain after round ${round}; rescanning and retrying\n`,
+            );
+            plan = finalPlan;
+          }
+        }
+      }
 
       const failed = results.filter((result) => Boolean(result.error)).length;
       const succeeded = results.filter((result) => !result.error);
@@ -2064,22 +2505,79 @@ async function main() {
       const reclaimedRentLamports = succeeded
         .filter((result) => result.action.kind === "close-empty")
         .reduce((sum, result) => sum + (result.action.rentLamports ?? 0n), 0n);
+
+      const residual = flags.has("live")
+        ? finalPlan.actions.filter(
+            (action) =>
+              action.amountRaw > 0n &&
+              action.kind !== "keep-protected" &&
+              action.kind !== "close-empty",
+          )
+        : [];
+
       emit(
         `DONE     ok=${succeeded.length}  failed=${failed}  ` +
           `native-sold=${soldNative}  jupiter-sold=${soldJupiter}  ` +
           `unwrapped=${unwrapped}  closed-empty=${closedEmpty}  ` +
+          `residual=${residual.length}  ` +
           `reclaimed-rent≈${(Number(reclaimedRentLamports) / 1e9).toFixed(6)} SOL\n`,
       );
+
+      if (residual.length) {
+        for (const action of residual.slice(0, 12)) {
+          const label = action.symbol ?? action.name ?? shortKey(action.mint);
+          emit(
+            `REMAIN   @${action.walletName}  ${label}  ${action.amountUi}  ` +
+              `${action.mint}${action.reason ? `  ${action.reason}` : ""}\n`,
+          );
+        }
+        if (residual.length > 12)
+          emit(`REMAIN   ... ${residual.length - 12} more holding(s)\n`);
+        emit(
+          `INCOMPLETE positive unprotected token balances remain after the final fresh scan\n`,
+        );
+        process.exitCode = 1;
+      }
       return;
     }
 
-    if (command === "sweep" && values[0] === "sol") {
-      const destinationInput = flags.get("to") ?? values[1];
+    if (command === "sweep") {
+      const legacySolSyntax = values[0]?.toLowerCase() === "sol";
+      const positionalDestination = legacySolSyntax ? values[1] : values[0];
+      const extraValues = legacySolSyntax ? values.slice(2) : values.slice(1);
+      if (extraValues.length > 0) {
+        throw new Error(
+          `${sweepUsage()}\nUnexpected argument: ${extraValues[0]}`,
+        );
+      }
+
+      const destinationInput = flags.get("to") ?? positionalDestination;
       if (!destinationInput || destinationInput === "true") {
+        throw new Error(sweepUsage());
+      }
+
+      const below = flags.get("below");
+      const maxBalance = flags.get("max-balance-sol");
+      if (below === "true") {
+        throw new Error(`--below requires a SOL amount.\n${sweepUsage()}`);
+      }
+      if (maxBalance === "true") {
         throw new Error(
-          "Usage: slrd sweep sol --to <contact|wallet|address> [--wallets <a,b,...>] [--max-balance-sol <SOL>] [--exclude-group <group>] [--exclude-prefix <prefix>] [--keep <wallet=SOL,...>] [--keep-if-tokens <SOL> | --keep-if-token <token>=<SOL>] [--simulate | --live] [--json]",
+          `--max-balance-sol requires a SOL amount.\n${sweepUsage()}`,
         );
       }
+      if (
+        below != null &&
+        maxBalance != null &&
+        maxBalance !== "true" &&
+        below !== maxBalance
+      ) {
+        throw new Error("Use either --below or --max-balance-sol, not both.");
+      }
+      const maxBalanceSol = below ?? maxBalance;
+      if (!legacySolSyntax && maxBalanceSol == null) {
+        throw new Error(`--below is required for slrd sweep.\n${sweepUsage()}`);
+      }
 
       const destination = resolveDestinationRef(slrd, destinationInput);
 
@@ -2120,16 +2618,26 @@ async function main() {
           "Use either --keep-if-tokens or --keep-if-token, not both",
         );
       }
+      if (flags.has("simulate") && flags.has("live")) {
+        throw new Error("Use either --simulate or --live, not both");
+      }
 
       const sweepMode = flags.has("live")
         ? "LIVE"
         : flags.has("simulate")
           ? "SIMULATE"
           : "PLAN";
-      if (!flags.has("json")) {
-        emit(`SWEEP ${sweepMode}  to=${destination.address}\n`);
+
+      if (!flags.has("json") && (flags.has("live") || flags.has("simulate"))) {
+        const initialDestinationLabel = destination.contactName
+          ? `${destination.contactName} (${destination.address})`
+          : destination.walletName
+            ? `${destination.walletName} (${destination.address})`
+            : destination.address;
+        emit(`SWEEP ${sweepMode} -> ${initialDestinationLabel}\n`);
+        if (maxBalanceSol != null) emit(`Threshold: < ${maxBalanceSol} SOL\n`);
         emit(
-          `RPC      hard limit ${process.env.SLRD_RPC_MAX_RPS ?? "5"} req/s\n`,
+          "PLAN  reading confirmed wallet balances and estimating transfer fee...\n",
         );
       }
 
@@ -2138,7 +2646,7 @@ async function main() {
         excludeGroups,
         excludePrefixes,
         includeWallets: includeWallets.length ? includeWallets : undefined,
-        maxBalanceSol: flags.get("max-balance-sol"),
+        maxBalanceSol,
         keepSolByWallet,
         defaultKeepSol: flags.get("default-keep-sol") ?? "0",
         keepSolIfTokens: flags.get("keep-if-tokens"),
@@ -2152,34 +2660,56 @@ async function main() {
           Math.trunc(int(flags, "rpc-delay-ms", 75) ?? 75),
         ),
         delayMs: int(flags, "delay-ms", 0) ?? 0,
-        onProgress: flags.has("json")
-          ? undefined
-          : (event: any) => {
-              if (event.stage === "plan-start") {
-                emit(`PLAN     ${event.wallets} candidate wallets\n`);
-              } else if (event.stage === "plan-ready") {
-                emit(
-                  `PLAN     ${event.sendWallets}/${event.wallets} will send, ` +
-                    `${formatRaw(event.totalSendLamports, 9)} SOL total\n`,
-                );
-              } else if (event.stage === "wallet-start") {
-                emit(
-                  `SEND     ${event.index}/${event.total}  @${event.row.walletName}  ` +
-                    `${formatRaw(event.row.sendLamports, 9)} SOL\n`,
-                );
-              } else if (event.stage === "wallet-done") {
-                emit(
-                  `OK       ${event.index}/${event.total}  @${event.row.walletName}\n`,
-                );
-              } else if (event.stage === "wallet-error") {
-                emit(
-                  `FAIL     ${event.index}/${event.total}  @${event.row.walletName}  ` +
-                    `${event.error}\n`,
-                );
+        maxAttempts: Math.max(
+          1,
+          Math.trunc(int(flags, "sweep-attempts", 3) ?? 3),
+        ),
+        confirmationTimeoutMs: Math.max(
+          1_000,
+          Math.trunc(int(flags, "confirm-timeout-ms", 15_000) ?? 15_000),
+        ),
+        confirmationPollMs: Math.max(
+          250,
+          Math.trunc(int(flags, "confirm-poll-ms", 750) ?? 750),
+        ),
+        onProgress:
+          !flags.has("json") && flags.has("live")
+            ? (event: any) => {
+                if (event.stage === "wallet-start") {
+                  emit(
+                    `SEND ${event.index}/${event.total}  @${event.row.walletName}  ` +
+                      `${formatRaw(event.row.sendLamports, 9)} SOL\n`,
+                  );
+                } else if (event.stage === "wallet-pending") {
+                  emit(
+                    `WAIT ${event.index}/${event.total}  @${event.row.walletName}  ` +
+                      `attempt=${event.attempt}/${event.maxAttempts}  ` +
+                      `${event.reason}\n`,
+                  );
+                } else if (event.stage === "wallet-done") {
+                  emit(
+                    `OK   ${event.index}/${event.total}  @${event.row.walletName}  ` +
+                      `remaining=${formatRaw(event.remainingLamports, 9)} SOL` +
+                      `${event.receipt?.status ? `  status=${event.receipt.status}` : "  state=already-settled"}\n`,
+                  );
+                } else if (event.stage === "wallet-error") {
+                  emit(
+                    `FAIL ${event.index}/${event.total}  @${event.row.walletName}  ` +
+                      `${event.error}\n`,
+                  );
+                }
               }
-            },
+            : undefined,
       };
       const plan = await planRegistrySolSweep(slrd, options);
+      const sendRows = plan.rows.filter(
+        (row) => row.sendLamports > 0n && !row.skippedReason,
+      );
+      const destinationLabel = destination.contactName
+        ? `${destination.contactName} (${plan.destination})`
+        : destination.walletName
+          ? `${destination.walletName} (${plan.destination})`
+          : plan.destination;
 
       const printablePlan = {
         mode: flags.has("live")
@@ -2193,6 +2723,7 @@ async function main() {
           contact: destination.contactName ?? null,
           wallet: destination.walletName ?? null,
         },
+        belowSol: maxBalanceSol ?? null,
         totalSendSol: formatRaw(plan.totalSendLamports, 9),
         rows: plan.rows.map((row) => ({
           wallet: row.walletName,
@@ -2216,37 +2747,40 @@ async function main() {
           return;
         }
 
+        emit(`SWEEP SOL -> ${destinationLabel}\n`);
+        if (maxBalanceSol != null) emit(`Threshold: < ${maxBalanceSol} SOL\n`);
         emit(
-          `SWEEP PLAN  to=${plan.destination}  ` +
-            `send=${formatRaw(plan.totalSendLamports, 9)} SOL  ` +
-            `wallets=${plan.rows.filter((row) => row.sendLamports > 0n).length}/${plan.rows.length}\n`,
+          `Scanned: ${plan.rows.length}  Send: ${sendRows.length}  ` +
+            `Skipped: ${plan.rows.length - sendRows.length}  ` +
+            `Total: ${formatRaw(plan.totalSendLamports, 9)} SOL\n`,
         );
 
         for (const row of plan.rows) {
           if (row.sendLamports <= 0n && !flags.has("show-skipped")) continue;
-          emit(
-            `${row.sendLamports > 0n ? "SEND" : "SKIP"}  ` +
-              `@${row.walletName.padEnd(18)} ` +
-              `balance=${formatRaw(row.balanceLamports, 9).padStart(12)}  ` +
-              `keep=${formatRaw(row.keepLamports, 9).padStart(5)}  ` +
-              `send=${formatRaw(row.sendLamports, 9).padStart(12)}` +
-              `${row.reserveReason === "specific-token" ? "  keep-token=yes" : ""}` +
-              `${row.skippedReason ? `  ${row.skippedReason}` : ""}\n`,
-          );
+          if (row.sendLamports > 0n) {
+            emit(
+              `  @${row.walletName}  ${formatRaw(row.balanceLamports, 9)} -> ` +
+                `${formatRaw(row.sendLamports, 9)} SOL\n`,
+            );
+          } else {
+            emit(
+              `  @${row.walletName}  ${formatRaw(row.balanceLamports, 9)}  ` +
+                `SKIP ${row.skippedReason ?? "not-sendable"}\n`,
+            );
+          }
         }
 
-        emit(
-          `\n${OWL} plan only; no signer was decrypted and nothing was submitted. ` +
-            `Use --json for full details, then --simulate or --live.\n`,
-        );
+        emit(`\nPreview only. Add --simulate to verify or --live to send.\n`);
         return;
       }
 
-      if (flags.has("simulate") && flags.has("live")) {
-        throw new Error("Use either --simulate or --live, not both");
-      }
-
       if (flags.has("simulate")) {
+        if (!flags.has("json")) {
+          emit(
+            `PLAN  eligible=${sendRows.length}/${plan.rows.length}  ` +
+              `total=${formatRaw(plan.totalSendLamports, 9)} SOL\n`,
+          );
+        }
         const results = await simulateRegistrySolSweep(slrd, plan, options);
         if (flags.has("json")) {
           emit(json({ ...printablePlan, results }) + "\n");
@@ -2254,22 +2788,33 @@ async function main() {
           const failed = results.filter(
             (result) => result.error || result.simulation?.success === false,
           ).length;
+          emit(`SWEEP SIMULATION -> ${destinationLabel}\n`);
           emit(
-            `SWEEP SIMULATION  attempted=${results.length}  ` +
-              `ok=${results.length - failed}  failed=${failed}  ` +
-              `to=${plan.destination}\n`,
+            `Attempted: ${results.length}  OK: ${results.length - failed}  ` +
+              `Failed: ${failed}  Total: ${formatRaw(plan.totalSendLamports, 9)} SOL\n`,
           );
           for (const result of results) {
             if (!result.error && result.simulation?.success !== false) continue;
             emit(
-              `FAIL  @${result.row.walletName}  ` +
+              `  FAIL @${result.row.walletName}  ` +
                 `${result.error ?? "simulation failed"}\n`,
             );
           }
+          emit("No transactions submitted.\n");
         }
         return;
       }
 
+      if (!flags.has("json")) {
+        emit(
+          `PLAN  eligible=${sendRows.length}/${plan.rows.length}  ` +
+            `total=${formatRaw(plan.totalSendLamports, 9)} SOL\n`,
+        );
+        if (sendRows.length === 0) {
+          emit("Nothing to sweep.\n");
+        }
+      }
+
       const receipts = await executeRegistrySolSweep(slrd, plan, options);
       if (flags.has("json")) {
         emit(json({ ...printablePlan, receipts }) + "\n");
@@ -2277,14 +2822,14 @@ async function main() {
         const failed = receipts.filter((result) =>
           Boolean(result.error),
         ).length;
+        emit(`SWEEP COMPLETE -> ${destinationLabel}\n`);
         emit(
-          `SWEEP LIVE  attempted=${receipts.length}  ` +
-            `ok=${receipts.length - failed}  failed=${failed}  ` +
-            `to=${plan.destination}\n`,
+          `Attempted: ${receipts.length}  OK: ${receipts.length - failed}  ` +
+            `Failed: ${failed}  Planned total: ${formatRaw(plan.totalSendLamports, 9)} SOL\n`,
         );
         for (const result of receipts) {
           if (!result.error) continue;
-          emit(`FAIL  @${result.row.walletName}  ${result.error}\n`);
+          emit(`  FAIL @${result.row.walletName}  ${result.error}\n`);
         }
       }
       return;
@@ -2310,150 +2855,183 @@ async function main() {
       command === "unwrap-wsol" ||
       (command === "unwrap" && values[0] === "wsol")
     ) {
-      const targets = targetWallets(
-        slrd,
-        flags,
-        "Usage: slrd unwrap-wsol (--wallet <wallet> | --wallets <w1,w2> | --group <group>).",
-      );
+      const allWallets = flags.has("all-wallets");
+      const explicitSelectors = [
+        Boolean(flags.get("wallet")),
+        csv(flags.get("wallets")).length > 0,
+        Boolean(flags.get("group")),
+      ].filter(Boolean).length;
+      if (allWallets && explicitSelectors > 0)
+        throw new Error(
+          "Use --all-wallets or a specific wallet selector, not both.",
+        );
+      const targets = allWallets
+        ? {
+            mode: "all-wallets" as const,
+            refs: slrd.wallets.list().map((wallet) => wallet.name),
+          }
+        : targetWallets(
+            slrd,
+            flags,
+            "Usage: slrd unwrap-wsol (--all-wallets | --wallet <wallet> | --wallets <w1,w2> | --group <group>).",
+          );
       const destination = flags.get("destination");
       if (destination && targets.refs.length !== 1)
         throw new Error(
           "--destination is only supported with a single --wallet unwrap.",
         );
-      const unwrapOptions = {
-        via: flags.get("sender") ?? "rpc",
-        destination,
-        skipMissing: flags.has("ignore-missing") || flags.has("skip-missing"),
-        skipSimulation: flags.has("skip-simulation"),
-        skipPreflight:
-          flags.has("skip-preflight") || flags.has("skip-simulation"),
-      };
-
-      const multiWallet = targets.refs.length > 1;
+      const skipMissing =
+        allWallets || flags.has("ignore-missing") || flags.has("skip-missing");
+      const via = flags.get("sender") ?? "rpc";
+      const skipSimulation = flags.has("skip-simulation");
+      const skipPreflight = flags.has("skip-preflight") || skipSimulation;
       const failFast = flags.has("fail-fast");
+      const results: Array<Record<string, unknown>> = [];
 
-      // Multi-wallet/group unwrap is resilient by default. Do not let one
-      // undecryptable wallet prevent unrelated wallets from recovering WSOL.
-      // With --ignore-missing, probe the WSOL ATA using only the public wallet
-      // address BEFORE asking the vault to decrypt the signer.
-      if (multiWallet && !failFast) {
-        const results: Array<Record<string, unknown>> = [];
-
-        for (const walletRef of targets.refs) {
-          const resolved = slrd.resolveWallet(walletRef);
-          const address = resolved.address.toBase58();
-          const label = resolved.row?.name ? `@${resolved.row.name}` : address;
-
-          if (unwrapOptions.skipMissing) {
-            const wsolAccount = wrappedSolAta(resolved.address);
-            const account = await slrd
-              .connection()
-              .getAccountInfo(wsolAccount, "confirmed");
-
-            if (!account) {
-              results.push({
-                wallet: walletRef,
-                address,
-                ok: true,
-                skipped: "missing-wsol",
-                wsolAccount: wsolAccount.toBase58(),
+      for (const walletRef of targets.refs) {
+        const resolved = slrd.resolveWallet(walletRef);
+        const address = resolved.address.toBase58();
+        const label = resolved.row?.name ? `@${resolved.row.name}` : address;
+        try {
+          const accounts = (await slrd.tokenAccounts(address)).filter(
+            (account) => account.mint === NATIVE_SOL_MINT,
+          );
+          if (!accounts.length) {
+            if (!skipMissing && targets.refs.length === 1)
+              throw new Error(`No WSOL token accounts exist for ${address}`);
+            results.push({
+              wallet: walletRef,
+              address,
+              ok: true,
+              skipped: "missing-wsol",
+            });
+            continue;
+          }
+
+          let closed = 0;
+          let unwrappedRaw = 0n;
+          const accountResults: Array<Record<string, unknown>> = [];
+          for (const account of accounts) {
+            if (account.closeAuthority && account.closeAuthority !== address) {
+              const error = `WSOL account ${account.address} has close authority ${account.closeAuthority}`;
+              accountResults.push({
+                account: account.address,
+                ok: false,
+                error,
               });
+              if (failFast) throw new Error(error);
               continue;
             }
-          }
-
-          try {
-            if (flags.has("simulate-only")) {
-              const plan = await slrd
+            try {
+              const composer = slrd
                 .tx(walletRef)
-                .unwrapWsol({ skipMissing: unwrapOptions.skipMissing })
-                .build();
-              const simulation = await slrd.simulatePlan(plan);
-              results.push({
-                wallet: walletRef,
-                address,
-                ok: simulation.success,
-                mode: "simulation",
-                simulation,
-              });
-            } else {
-              const receipt = await slrd.unwrapWsol(walletRef, unwrapOptions);
-              results.push({
-                wallet: walletRef,
-                address,
-                ok: true,
-                receipt,
+                .closeTokenAccountAddress(
+                  account.address,
+                  account.tokenProgram,
+                  {
+                    destination,
+                  },
+                );
+              if (flags.has("simulate-only")) {
+                const plan = await composer.build();
+                const simulation = await slrd.simulatePlan(plan);
+                if (!simulation.success) throw new Error("simulation failed");
+                accountResults.push({
+                  account: account.address,
+                  amountRaw: account.amountRaw,
+                  ok: true,
+                  mode: "simulation",
+                  simulation,
+                });
+              } else {
+                const receipt = await composer.send({
+                  via,
+                  kind: "unwrap-wsol:account",
+                  skipSimulation,
+                  skipPreflight,
+                });
+                const { PublicKey } = await import("@solana/web3.js");
+                let closedOnChain = false;
+                for (let attempt = 0; attempt < 6; attempt += 1) {
+                  const current = await slrd
+                    .connection()
+                    .getAccountInfo(
+                      new PublicKey(account.address),
+                      "confirmed",
+                    );
+                  if (!current || current.lamports === 0) {
+                    closedOnChain = true;
+                    break;
+                  }
+                  if (attempt < 5)
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                }
+                if (!closedOnChain)
+                  throw new Error(
+                    `WSOL account ${account.address} still exists after close`,
+                  );
+                accountResults.push({
+                  account: account.address,
+                  amountRaw: account.amountRaw,
+                  ok: true,
+                  receipt,
+                });
+              }
+              closed += 1;
+              unwrappedRaw += BigInt(account.amountRaw);
+            } catch (error) {
+              const message =
+                error instanceof Error ? error.message : String(error);
+              accountResults.push({
+                account: account.address,
+                ok: false,
+                error: message,
               });
+              if (failFast) throw error;
             }
-          } catch (error) {
-            const message =
-              error instanceof Error ? error.message : String(error);
-            results.push({
-              wallet: walletRef,
-              address,
-              ok: false,
-              error: message,
-            });
-            process.stderr.write(
-              `${OWL} unwrap-wsol ${label} (${address}) failed: ${message}\n`,
-            );
           }
+          const failedAccounts = accountResults.filter(
+            (row) => row.ok === false,
+          ).length;
+          results.push({
+            wallet: walletRef,
+            address,
+            ok: failedAccounts === 0,
+            closed,
+            failedAccounts,
+            unwrappedRaw,
+            accounts: accountResults,
+          });
+        } catch (error) {
+          const message =
+            error instanceof Error ? error.message : String(error);
+          results.push({
+            wallet: walletRef,
+            address,
+            ok: false,
+            error: message,
+          });
+          process.stderr.write(
+            `${OWL} unwrap-wsol ${label} (${address}) failed: ${message}\n`,
+          );
+          if (failFast) throw error;
         }
-
-        const succeeded = results.filter(
-          (row) => row.ok === true && !row.skipped,
-        ).length;
-        const skipped = results.filter((row) => Boolean(row.skipped)).length;
-        const failed = results.filter((row) => row.ok === false).length;
-
-        emit(
-          json({
-            mode: flags.has("simulate-only")
-              ? "wallet-by-wallet-simulation"
-              : "wallet-by-wallet",
-            target: targets,
-            summary: {
-              total: results.length,
-              succeeded,
-              skipped,
-              failed,
-            },
-            results,
-          }) + "\n",
-        );
-        return;
-      }
-
-      // Single-wallet unwrap remains fail-fast. --fail-fast also preserves the
-      // old batch behavior for callers that explicitly want all-or-nothing.
-      if (flags.has("simulate-only")) {
-        const plans =
-          targets.refs.length === 1
-            ? [
-                await slrd
-                  .tx(targets.refs[0]!)
-                  .unwrapWsol({
-                    destination,
-                    skipMissing: unwrapOptions.skipMissing,
-                  })
-                  .build(),
-              ]
-            : await slrd
-                .composeMany(targets.refs)
-                .unwrapWsol({ skipMissing: unwrapOptions.skipMissing })
-                .build();
-        const results = await Promise.all(
-          plans.map((plan) => slrd.simulatePlan(plan)),
-        );
-        emit(json({ mode: "simulation", target: targets, results }) + "\n");
-        return;
       }
 
-      const receipts =
-        targets.refs.length === 1
-          ? await slrd.unwrapWsol(targets.refs[0]!, unwrapOptions)
-          : await slrd.unwrapWsolMany(targets.refs, unwrapOptions);
-      emit(json(receipts) + "\n");
+      const succeeded = results.filter(
+        (row) => row.ok === true && !row.skipped,
+      ).length;
+      const skipped = results.filter((row) => Boolean(row.skipped)).length;
+      const failed = results.filter((row) => row.ok === false).length;
+      emit(
+        json({
+          mode: flags.has("simulate-only") ? "simulation" : "live",
+          target: targets,
+          summary: { total: results.length, succeeded, skipped, failed },
+          results,
+        }) + "\n",
+      );
+      if (failed) process.exitCode = 1;
       return;
     }
     if (command === "rewards") {
@@ -2742,7 +3320,9 @@ async function main() {
       );
       return;
     }
-    throw new Error(`Unknown command: ${command}\n\n${help()}`);
+    throw new Error(
+      `Unknown command: ${command}. Run "slrd help" for available commands.`,
+    );
   } finally {
     slrd.close();
   }