@grimoirelabs/cli 0.14.2 → 0.15.1

package/dist/commands/cast.js

@@ -3,24 +3,24 @@
  * Executes a spell with optional live execution via private key
  */
 import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import * as readline from "node:readline";
-import { Writable } from "node:stream";
-import { compileFile, createProvider, createRunRecord, createWalletFromConfig, execute, formatWei, getChainName, getNativeCurrencySymbol, isTestnet, loadPrivateKey, orchestrateCrossChain, SqliteStateStore, toCrossChainReceipt, } from "@grimoirelabs/core";
-import { adapters, createAlchemyQueryProvider, createHyperliquidAdapter, } from "@grimoirelabs/venues";
+import { compileFile, createProvider, createWalletFromConfig, execute, formatWei, getChainName, getNativeCurrencySymbol, isTestnet, } from "@grimoirelabs/core";
+import { adapters, createAlchemyQueryProvider } from "@grimoirelabs/venues";
 import chalk from "chalk";
 import ora from "ora";
 import { hydrateParamsFromEnsProfile, resolveEnsProfile } from "../lib/ens-profile.js";
+import { resolveNoState, resolveRpcUrlFromOption } from "../lib/execution-helpers.js";
+import { stringifyJson } from "../lib/json.js";
+import { DEFAULT_KEYSTORE_PATH } from "../lib/keystore.js";
+import { confirmPrompt } from "../lib/prompts.js";
 import { resolveAdvisorSkillsDirs } from "./advisor-skill-helpers.js";
 import { resolveAdvisoryHandler } from "./advisory-handlers.js";
 import { createAdvisoryLiveTraceLogger } from "./advisory-live-trace.js";
-import { createLogicalRunId, parseMorphoMarketMappings, parseRpcUrlMappings, requireExplicitRpcMappings, resolveRpcUrlForChain, validateMorphoMappingsForSpells, } from "./cross-chain-helpers.js";
+import { configureHyperliquidAdapters, executeCrossChainCast, resolveKeystorePassword, safeGetBlockNumber, } from "./cast-cross-chain.js";
 import { buildRuntimeProvenanceManifest, enforceFreshnessPolicy, resolveDataPolicy, resolveReplayParams, } from "./data-provenance.js";
 import { buildRunReportEnvelope, formatRunReportText } from "./run-report.js";
 import { spellUsesQueryFunctions } from "./spell-analysis.js";
 import { withStatePersistence } from "./state-helpers.js";
-const DEFAULT_KEYSTORE_PATH = join(homedir(), ".grimoire", "keystore.json");
+const DEFAULT_GAS_MULTIPLIER = 1.1;
 export async function castCommand(spellPath, options) {
     const spinner = ora(`Loading ${spellPath}...`).start();
     try {
@@ -31,23 +31,23 @@ export async function castCommand(spellPath, options) {
             }
             catch {
                 spinner.fail(chalk.red("Invalid params JSON"));
-                process.exit(1);
+                throw new Error("Cast failed");
             }
         }
         if (options.ensName) {
             spinner.text = `Resolving ENS profile ${options.ensName}...`;
             const profile = await resolveEnsProfile(options.ensName, { rpcUrl: options.ensRpcUrl });
             params = hydrateParamsFromEnsProfile(params, profile);
-            console.log(chalk.dim(`ENS profile ${profile.name} -> ${profile.address ?? "unresolved"} (risk=${profile.riskProfile ?? "n/a"}, slippage=${profile.maxSlippageBps ?? "n/a"})`));
+            console.error(chalk.dim(`ENS profile ${profile.name} -> ${profile.address ?? "unresolved"} (risk=${profile.riskProfile ?? "n/a"}, slippage=${profile.maxSlippageBps ?? "n/a"})`));
         }
         spinner.text = "Compiling spell...";
         const compileResult = await compileFile(spellPath);
         if (!compileResult.success || !compileResult.ir) {
             spinner.fail(chalk.red("Compilation failed"));
             for (const error of compileResult.errors) {
-                console.log(chalk.red(`  [${error.code}] ${error.message}`));
+                console.error(chalk.red(`  [${error.code}] ${error.message}`));
             }
-            process.exit(1);
+            throw new Error("Cast failed");
         }
         const spell = compileResult.ir;
         spinner.succeed(chalk.green("Spell compiled successfully"));
@@ -55,7 +55,7 @@ export async function castCommand(spellPath, options) {
         if (options.trigger) {
             const anyTrigger = spell.triggers.find((t) => t.type === "any");
             if (!anyTrigger || anyTrigger.type !== "any" || !spell.triggerStepMap) {
-                console.log(chalk.yellow(`Warning: --trigger "${options.trigger}" ignored — spell has a single trigger (no filtering needed).`));
+                console.error(chalk.yellow(`Warning: --trigger "${options.trigger}" ignored — spell has a single trigger (no filtering needed).`));
             }
         }
         const noState = resolveNoState(options);
@@ -80,20 +80,20 @@ export async function castCommand(spellPath, options) {
         });
         params = replayResolution.params;
         if (options.privateKey || options.mnemonic) {
-            console.log(chalk.yellow("⚠️  Avoid passing secrets via CLI arguments. Use --key-env or env vars instead."));
+            console.error(chalk.yellow("Warning: Avoid passing secrets via CLI arguments. Use --key-env or env vars instead."));
         }
-        console.log();
-        console.log(chalk.cyan("📜 Spell Info:"));
-        console.log(`  ${chalk.dim("Name:")} ${spell.meta.name}`);
-        console.log(`  ${chalk.dim("Version:")} ${spell.version}`);
-        console.log(`  ${chalk.dim("Steps:")} ${spell.steps.length}`);
-        console.log(`  ${chalk.dim("Mode:")} ${mode}`);
+        console.error();
+        console.error(chalk.cyan("Spell Info:"));
+        console.error(`  ${chalk.dim("Name:")} ${spell.meta.name}`);
+        console.error(`  ${chalk.dim("Version:")} ${spell.version}`);
+        console.error(`  ${chalk.dim("Steps:")} ${spell.steps.length}`);
+        console.error(`  ${chalk.dim("Mode:")} ${mode}`);
         if (spell.params.length > 0) {
-            console.log();
-            console.log(chalk.cyan("📊 Parameters:"));
+            console.error();
+            console.error(chalk.cyan("Parameters:"));
             for (const param of spell.params) {
                 const value = params[param.name] ?? param.default;
-                console.log(`  ${chalk.dim(param.name)}: ${JSON.stringify(value)}`);
+                console.error(`  ${chalk.dim(param.name)}: ${JSON.stringify(value)}`);
             }
         }
         const chainId = Number.parseInt(options.chain ?? "1", 10);
@@ -114,16 +114,16 @@ export async function castCommand(spellPath, options) {
             });
             return;
         }
-        console.log();
-        console.log(chalk.cyan("🔗 Network:"));
-        console.log(`  ${chalk.dim("Chain:")} ${chainName} (${chainId})`);
-        console.log(`  ${chalk.dim("Testnet:")} ${isTest ? "Yes" : "No"}`);
+        console.error();
+        console.error(chalk.cyan("Network:"));
+        console.error(`  ${chalk.dim("Chain:")} ${chainName} (${chainId})`);
+        console.error(`  ${chalk.dim("Testnet:")} ${isTest ? "Yes" : "No"}`);
         if (hasKey && mode !== "simulate") {
-            await executeWithWallet(spell, params, options, noState, chainId, isTest, dataPolicy, replayResolution);
+            return await executeWithWallet(spell, params, options, noState, chainId, isTest, dataPolicy, replayResolution);
         }
         else {
             const runtimeFlow = mode === "dry-run" ? "cast_dry_run" : "simulate";
-            await executeSimulation(spell, params, options, noState, chainId, runtimeFlow, dataPolicy, replayResolution);
+            return await executeSimulation(spell, params, options, noState, chainId, runtimeFlow, dataPolicy, replayResolution);
         }
     }
     catch (error) {
@@ -131,7 +131,7 @@ export async function castCommand(spellPath, options) {
         if (options.verbose) {
             console.error(error);
         }
-        process.exit(1);
+        throw new Error("Cast failed");
     }
 }
 async function executeWithWallet(spell, params, options, noState, chainId, isTest, dataPolicy, replayResolution) {
@@ -150,33 +150,17 @@ async function executeWithWallet(spell, params, options, noState, chainId, isTes
         const keystorePath = options.keystore ?? DEFAULT_KEYSTORE_PATH;
         if (!existsSync(keystorePath)) {
             spinner.fail(chalk.red(`No key provided and no keystore found at ${keystorePath}`));
-            console.log(chalk.dim("  Run 'grimoire wallet generate' to create one."));
-            process.exit(1);
-            return;
+            console.error(chalk.dim("  Run 'grimoire wallet generate' to create one."));
+            throw new Error("Cast failed");
         }
         const password = await resolveKeystorePassword(options, spinner);
         if (!password) {
-            return;
+            throw new Error("Cast failed");
         }
         const keystoreJson = readFileSync(keystorePath, "utf-8");
         keyConfig = { type: "keystore", source: keystoreJson, password };
     }
-    let configuredAdapters = adapters;
-    try {
-        const rawKey = loadPrivateKey(keyConfig);
-        configuredAdapters = adapters.map((adapter) => {
-            if (adapter.meta.name === "hyperliquid") {
-                return createHyperliquidAdapter({
-                    privateKey: rawKey,
-                    assetMap: { ETH: 4 },
-                });
-            }
-            return adapter;
-        });
-    }
-    catch {
-        // Keep default adapters if key extraction fails.
-    }
+    const configuredAdapters = configureHyperliquidAdapters(keyConfig);
     const rpcUrl = resolveRpcUrlFromOption(chainId, options.rpcUrl);
     if (!rpcUrl) {
         spinner.warn(chalk.yellow("No RPC URL provided, using default public RPC"));
@@ -185,21 +169,23 @@ async function executeWithWallet(spell, params, options, noState, chainId, isTes
     const wallet = createWalletFromConfig(keyConfig, chainId, provider.rpcUrl);
     spinner.succeed(chalk.green(`Wallet loaded: ${wallet.address}`));
     const balance = await provider.getBalance(wallet.address);
-    console.log(`  ${chalk.dim("Balance:")} ${formatWei(balance)} ${getNativeCurrencySymbol(chainId)}`);
+    console.error(`  ${chalk.dim("Balance:")} ${formatWei(balance)} ${getNativeCurrencySymbol(chainId)}`);
     if (balance === 0n) {
-        console.log(chalk.yellow(`  ⚠️  Wallet has no ${getNativeCurrencySymbol(chainId)} for gas`));
+        console.error(chalk.yellow(`  Warning: Wallet has no ${getNativeCurrencySymbol(chainId)} for gas`));
     }
     const vault = (options.vault ?? wallet.address);
     const queryProvider = createAlchemyQueryProvider({ provider, chainId, vault, rpcUrl });
-    console.log(`  ${chalk.dim("Vault:")} ${vault}`);
+    console.error(`  ${chalk.dim("Vault:")} ${vault}`);
     if (!isTest) {
-        console.log();
-        console.log(chalk.red("⚠️  WARNING: This is MAINNET"));
-        console.log(chalk.red("   Real funds will be used!"));
+        console.error();
+        console.error(chalk.red("WARNING: This is MAINNET"));
+        console.error(chalk.red("   Real funds will be used!"));
     }
     const executionMode = options.dryRun ? "dry-run" : "execute";
     const runtimeMode = executionMode === "dry-run" ? "cast_dry_run" : "cast_execute";
-    const gasMultiplier = options.gasMultiplier ? Number.parseFloat(options.gasMultiplier) : 1.1;
+    const gasMultiplier = options.gasMultiplier
+        ? Number.parseFloat(options.gasMultiplier)
+        : DEFAULT_GAS_MULTIPLIER;
     const advisorSkillsDirs = resolveAdvisorSkillsDirs(options.advisorSkillsDir) ?? [];
     const onAdvisory = await resolveAdvisoryHandler(spell.id, {
         advisoryPi: options.advisoryPi,
@@ -209,7 +195,7 @@ async function executeWithWallet(spell, params, options, noState, chainId, isTes
         advisoryThinking: options.advisoryThinking,
         advisoryTools: options.advisoryTools,
         advisoryTraceVerbose: options.advisoryTraceVerbose,
-        advisoryTraceLogger: options.json ? undefined : console.log,
+        advisoryTraceLogger: options.json ? undefined : console.error,
         advisorSkillsDirs,
         stateDir: options.stateDir,
         noState,
@@ -218,7 +204,7 @@ async function executeWithWallet(spell, params, options, noState, chainId, isTes
     });
     const eventCallback = options.json
         ? undefined
-        : createAdvisoryLiveTraceLogger(console.log, {
+        : createAdvisoryLiveTraceLogger(console.error, {
             verbose: options.advisoryTraceVerbose,
         });
     const provenance = buildRuntimeProvenanceManifest({
@@ -232,22 +218,22 @@ async function executeWithWallet(spell, params, options, noState, chainId, isTes
     });
     const freshnessWarnings = enforceFreshnessPolicy(provenance);
     for (const warning of freshnessWarnings) {
-        console.log(chalk.yellow(`Warning: ${warning}`));
+        console.error(chalk.yellow(`Warning: ${warning}`));
     }
     const confirmCallback = options.skipConfirm || isTest
         ? async () => true
         : async (message) => {
-            console.log(message);
+            console.error(message);
             return await confirmPrompt(chalk.yellow("Proceed? (yes/no): "));
         };
-    console.log();
-    console.log(chalk.cyan(`🚀 Executing spell (${executionMode})...`));
+    console.error();
+    console.error(chalk.cyan(`Executing spell (${executionMode})...`));
     const execResult = await withStatePersistence(spell.id, {
         stateDir: options.stateDir,
         noState,
         buildRunProvenance: () => provenance,
         onUnavailable: () => {
-            console.log(chalk.yellow("State persistence unavailable in Node (missing better-sqlite3). Continuing without persisted state."));
+            console.error(chalk.yellow("State persistence unavailable in Node (missing better-sqlite3). Continuing without persisted state."));
         },
     }, async (persistentState) => {
         return execute({
@@ -263,7 +249,7 @@ async function executeWithWallet(spell, params, options, noState, chainId, isTes
             gasMultiplier,
             confirmCallback,
             progressCallback: (message) => {
-                console.log(chalk.dim(`  ${message}`));
+                console.error(chalk.dim(`  ${message}`));
             },
             skipTestnetConfirmation: options.skipConfirm ?? false,
             adapters: configuredAdapters,
@@ -275,38 +261,39 @@ async function executeWithWallet(spell, params, options, noState, chainId, isTes
         });
     });
     if (execResult.success) {
-        console.log(chalk.green("Execution completed successfully"));
+        console.error(chalk.green("Execution completed successfully"));
     }
     else {
-        console.log(chalk.red(`Execution failed: ${execResult.error}`));
+        console.error(chalk.red(`Execution failed: ${execResult.error}`));
     }
     const report = buildRunReportEnvelope({
         spellName: spell.meta.name,
         result: execResult,
         provenance,
     });
-    console.log();
+    const payload = execResult.commit
+        ? {
+            success: execResult.success,
+            preview: execResult.receipt,
+            commit: execResult.commit,
+            error: execResult.structuredError,
+        }
+        : {
+            success: execResult.success,
+            receipt: execResult.receipt,
+            error: execResult.structuredError,
+        };
+    console.error();
     if (options.json) {
-        const payload = execResult.commit
-            ? {
-                success: execResult.success,
-                preview: execResult.receipt,
-                commit: execResult.commit,
-                error: execResult.structuredError,
-            }
-            : {
-                success: execResult.success,
-                receipt: execResult.receipt,
-                error: execResult.structuredError,
-            };
-        console.log(stringifyJson(payload));
+        console.error(stringifyJson(payload));
     }
     else {
-        console.log(formatRunReportText(report));
+        console.error(formatRunReportText(report));
     }
     if (!execResult.success) {
-        process.exit(1);
+        throw new Error("Cast failed");
     }
+    return payload;
 }
 async function executeSimulation(spell, params, options, noState, chainId, runtimeMode, dataPolicy, replayResolution) {
     const spinner = ora("Running simulation...").start();
@@ -319,7 +306,7 @@ async function executeSimulation(spell, params, options, noState, chainId, runti
     });
     const freshnessWarnings = enforceFreshnessPolicy(provenance);
     for (const warning of freshnessWarnings) {
-        console.log(chalk.yellow(`Warning: ${warning}`));
+        console.error(chalk.yellow(`Warning: ${warning}`));
     }
     const vault = (options.vault ?? "0x0000000000000000000000000000000000000000");
     const simRpcUrl = resolveRpcUrlFromOption(chainId, options.rpcUrl);
@@ -337,7 +324,7 @@ async function executeSimulation(spell, params, options, noState, chainId, runti
         advisoryThinking: options.advisoryThinking,
         advisoryTools: options.advisoryTools,
         advisoryTraceVerbose: options.advisoryTraceVerbose,
-        advisoryTraceLogger: options.json ? undefined : console.log,
+        advisoryTraceLogger: options.json ? undefined : console.error,
         advisorSkillsDirs,
         stateDir: options.stateDir,
         noState,
@@ -346,7 +333,7 @@ async function executeSimulation(spell, params, options, noState, chainId, runti
     });
     const eventCallback = options.json
         ? undefined
-        : createAdvisoryLiveTraceLogger(console.log, {
+        : createAdvisoryLiveTraceLogger(console.error, {
             verbose: options.advisoryTraceVerbose,
         });
     // execute() with simulate:true internally uses preview()
@@ -355,7 +342,7 @@ async function executeSimulation(spell, params, options, noState, chainId, runti
         noState,
         buildRunProvenance: () => provenance,
         onUnavailable: () => {
-            console.log(chalk.yellow("State persistence unavailable in Node (missing better-sqlite3). Continuing without persisted state."));
+            console.error(chalk.yellow("State persistence unavailable in Node (missing better-sqlite3). Continuing without persisted state."));
         },
     }, async (persistentState) => {
         return execute({
@@ -385,633 +372,21 @@ async function executeSimulation(spell, params, options, noState, chainId, runti
         result,
         provenance,
     });
-    console.log();
-    if (options.json) {
-        const payload = {
-            success: result.success,
-            receipt: result.receipt,
-            error: result.structuredError,
-        };
-        console.log(stringifyJson(payload));
-    }
-    else {
-        console.log(formatRunReportText(report));
-    }
-    if (!result.success) {
-        process.exit(1);
-    }
-}
-async function executeCrossChainCast(input) {
-    const destinationSpellPath = input.options.destinationSpell;
-    if (!destinationSpellPath) {
-        throw new Error("Cross-chain mode requires --destination-spell");
-    }
-    const destinationChainId = parseRequiredNumber(input.options.destinationChain, "--destination-chain");
-    const handoffTimeoutSec = parseRequiredNumber(input.options.handoffTimeoutSec, "--handoff-timeout-sec");
-    const pollIntervalSec = input.options.pollIntervalSec
-        ? parseRequiredNumber(input.options.pollIntervalSec, "--poll-interval-sec")
-        : 30;
-    const destinationCompile = await compileFile(destinationSpellPath);
-    if (!destinationCompile.success || !destinationCompile.ir) {
-        throw new Error(`Destination spell compilation failed: ${destinationCompile.errors.map((e) => `[${e.code}] ${e.message}`).join("; ")}`);
-    }
-    const destinationSpell = destinationCompile.ir;
-    const rpcMappings = parseRpcUrlMappings(input.options.rpcUrl);
-    requireExplicitRpcMappings(rpcMappings, input.sourceChainId, destinationChainId);
-    const sourceRpcUrl = resolveRpcUrlForChain(input.sourceChainId, rpcMappings);
-    const destinationRpcUrl = resolveRpcUrlForChain(destinationChainId, rpcMappings);
-    if (!sourceRpcUrl || !destinationRpcUrl) {
-        throw new Error("Could not resolve RPC URLs for both source and destination chains.");
-    }
-    const morphoMarketIds = parseMorphoMarketMappings({
-        morphoMarketId: input.options.morphoMarketId,
-        morphoMarketMap: input.options.morphoMarketMap,
-    });
-    validateMorphoMappingsForSpells(input.sourceSpell, destinationSpell, morphoMarketIds);
-    const sourceProvider = createProvider(input.sourceChainId, sourceRpcUrl);
-    const destinationProvider = createProvider(destinationChainId, destinationRpcUrl);
-    const spinner = ora("Preparing cross-chain orchestration...").start();
-    let keyConfig;
-    let configuredAdapters = adapters;
-    let sourceWallet;
-    let destinationWallet;
-    if (input.mode === "execute") {
-        keyConfig = await resolveKeyConfig(input.options, spinner);
-        try {
-            const rawKey = loadPrivateKey(keyConfig);
-            configuredAdapters = adapters.map((adapter) => {
-                if (adapter.meta.name === "hyperliquid") {
-                    return createHyperliquidAdapter({
-                        privateKey: rawKey,
-                        assetMap: { ETH: 4 },
-                    });
-                }
-                return adapter;
-            });
-        }
-        catch {
-            configuredAdapters = adapters;
-        }
-        sourceWallet = createWalletFromConfig(keyConfig, input.sourceChainId, sourceProvider.rpcUrl);
-        destinationWallet = createWalletFromConfig(keyConfig, destinationChainId, destinationProvider.rpcUrl);
-    }
-    else if (input.hasKey) {
-        keyConfig = await resolveKeyConfig(input.options, spinner);
-        try {
-            const rawKey = loadPrivateKey(keyConfig);
-            configuredAdapters = adapters.map((adapter) => {
-                if (adapter.meta.name === "hyperliquid") {
-                    return createHyperliquidAdapter({
-                        privateKey: rawKey,
-                        assetMap: { ETH: 4 },
-                    });
-                }
-                return adapter;
-            });
-        }
-        catch {
-            configuredAdapters = adapters;
-        }
-    }
-    const vault = resolveVaultAddress(input.options.vault, sourceWallet?.address);
-    const runId = createLogicalRunId();
-    const runtimeFlow = input.mode === "execute"
-        ? "cast_execute"
-        : input.mode === "dry-run"
-            ? "cast_dry_run"
-            : "simulate";
-    const advisorSkillsDirs = resolveAdvisorSkillsDirs(input.options.advisorSkillsDir) ?? [];
-    const sourceOnAdvisory = await resolveAdvisoryHandler(input.sourceSpell.id, {
-        advisoryPi: input.options.advisoryPi,
-        advisoryReplay: input.options.advisoryReplay,
-        advisoryProvider: input.options.advisoryProvider,
-        advisoryModel: input.options.advisoryModel,
-        advisoryThinking: input.options.advisoryThinking,
-        advisoryTools: input.options.advisoryTools,
-        advisoryTraceVerbose: input.options.advisoryTraceVerbose,
-        advisoryTraceLogger: input.options.json ? undefined : console.log,
-        advisorSkillsDirs,
-        stateDir: input.options.stateDir,
-        noState: input.noState,
-        agentDir: input.options.piAgentDir,
-        cwd: process.cwd(),
-    });
-    const destinationOnAdvisory = await resolveAdvisoryHandler(destinationSpell.id, {
-        advisoryPi: input.options.advisoryPi,
-        advisoryReplay: input.options.advisoryReplay,
-        advisoryProvider: input.options.advisoryProvider,
-        advisoryModel: input.options.advisoryModel,
-        advisoryThinking: input.options.advisoryThinking,
-        advisoryTools: input.options.advisoryTools,
-        advisoryTraceVerbose: input.options.advisoryTraceVerbose,
-        advisoryTraceLogger: input.options.json ? undefined : console.log,
-        advisorSkillsDirs,
-        stateDir: input.options.stateDir,
-        noState: input.noState,
-        agentDir: input.options.piAgentDir,
-        cwd: process.cwd(),
-    });
-    const advisoryEventCallback = input.options.json
-        ? undefined
-        : createAdvisoryLiveTraceLogger(console.log, {
-            verbose: input.options.advisoryTraceVerbose,
-        });
-    const dbPath = input.options.stateDir ? join(input.options.stateDir, "grimoire.db") : undefined;
-    let store;
-    if (!input.noState) {
-        try {
-            store = new SqliteStateStore({ dbPath });
-        }
-        catch (error) {
-            if (isMissingNodeSqliteBackend(error)) {
-                console.log(chalk.yellow("State persistence unavailable in Node (missing better-sqlite3). Continuing without persisted state."));
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    let sourceState = store ? ((await store.load(input.sourceSpell.id)) ?? {}) : {};
-    let destinationState = store ? ((await store.load(destinationSpell.id)) ?? {}) : {};
-    const lifecycleEvents = [];
-    const manifest = {
-        schema_version: "grimoire.cross_chain.phase1.v1",
-        run_id: runId,
-        source_spell_path: input.sourceSpellPath,
-        destination_spell_path: destinationSpellPath,
-        source_spell_id: input.sourceSpell.id,
-        destination_spell_id: destinationSpell.id,
-        source_chain_id: input.sourceChainId,
-        destination_chain_id: destinationChainId,
-        mode: input.mode,
-        watch: input.options.watch === true,
-        handoff_timeout_sec: handoffTimeoutSec,
-        poll_interval_sec: pollIntervalSec,
-        rpc_by_chain: {
-            [input.sourceChainId]: sourceRpcUrl,
-            [destinationChainId]: destinationRpcUrl,
-        },
-        params: input.params,
-        vault,
-        morpho_market_ids: morphoMarketIds,
+    const payload = {
+        success: result.success,
+        receipt: result.receipt,
+        error: result.structuredError,
     };
-    const gasMultiplier = input.options.gasMultiplier
-        ? Number.parseFloat(input.options.gasMultiplier)
-        : 1.1;
-    const confirmCallback = input.options.skipConfirm || isTestnet(input.sourceChainId)
-        ? async () => true
-        : async (message) => {
-            console.log(message);
-            return await confirmPrompt(chalk.yellow("Proceed? (yes/no): "));
-        };
-    spinner.text = "Running source/destination orchestration...";
-    const orchestration = await orchestrateCrossChain({
-        runId,
-        sourceSpellId: input.sourceSpell.id,
-        destinationSpellId: destinationSpell.id,
-        sourceChainId: input.sourceChainId,
-        destinationChainId,
-        vault: vault,
-        sourceParams: input.params,
-        destinationParams: input.params,
-        mode: input.mode,
-        watch: input.options.watch === true,
-        handoffTimeoutSec,
-        pollIntervalSec,
-        executeSource: async () => {
-            const result = await execute({
-                spell: input.sourceSpell,
-                runId,
-                vault: vault,
-                chain: input.sourceChainId,
-                params: input.params,
-                persistentState: sourceState,
-                simulate: input.mode === "simulate",
-                executionMode: input.mode === "simulate" ? undefined : input.mode,
-                wallet: input.mode === "execute" ? sourceWallet : undefined,
-                provider: sourceProvider,
-                gasMultiplier,
-                confirmCallback,
-                skipTestnetConfirmation: input.options.skipConfirm ?? false,
-                adapters: configuredAdapters,
-                advisorSkillsDirs: advisorSkillsDirs.length > 0 ? advisorSkillsDirs : undefined,
-                onAdvisory: sourceOnAdvisory,
-                eventCallback: advisoryEventCallback,
-                warningCallback: (message) => console.log(chalk.yellow(`Warning: ${message}`)),
-                crossChain: {
-                    enabled: true,
-                    runId,
-                    trackId: "source",
-                    role: "source",
-                    morphoMarketIds,
-                },
-            });
-            sourceState = result.finalState;
-            return result;
-        },
-        executeDestination: async (params) => {
-            const result = await execute({
-                spell: destinationSpell,
-                runId,
-                vault: vault,
-                chain: destinationChainId,
-                params,
-                persistentState: destinationState,
-                simulate: input.mode === "simulate",
-                executionMode: input.mode === "simulate" ? undefined : input.mode,
-                wallet: input.mode === "execute" ? destinationWallet : undefined,
-                provider: destinationProvider,
-                gasMultiplier,
-                confirmCallback,
-                skipTestnetConfirmation: input.options.skipConfirm ?? false,
-                adapters: configuredAdapters,
-                advisorSkillsDirs: advisorSkillsDirs.length > 0 ? advisorSkillsDirs : undefined,
-                onAdvisory: destinationOnAdvisory,
-                eventCallback: advisoryEventCallback,
-                warningCallback: (message) => console.log(chalk.yellow(`Warning: ${message}`)),
-                crossChain: {
-                    enabled: true,
-                    runId,
-                    trackId: "destination",
-                    role: "destination",
-                    morphoMarketIds,
-                },
-            });
-            destinationState = result.finalState;
-            return result;
-        },
-        resolveHandoffStatus: async (handoff) => {
-            const across = configuredAdapters.find((adapter) => adapter.meta.name === "across");
-            if (!across) {
-                return { status: "pending" };
-            }
-            const resolver = across.bridgeLifecycle?.resolveHandoffStatus ?? across.resolveHandoffStatus;
-            if (!resolver) {
-                return { status: "pending" };
-            }
-            return resolver({
-                handoffId: handoff.handoffId,
-                originChainId: handoff.originChainId,
-                destinationChainId: handoff.destinationChainId,
-                originTxHash: handoff.originTxHash,
-                reference: handoff.reference,
-                asset: handoff.asset,
-                submittedAmount: handoff.submittedAmount,
-                walletAddress: vault,
-            });
-        },
-        onLifecycleEvent: (event) => {
-            lifecycleEvents.push(event);
-        },
-    });
-    const crossChainReceipt = toCrossChainReceipt({
-        runId,
-        sourceSpellId: input.sourceSpell.id,
-        destinationSpellId: destinationSpell.id,
-        sourceChainId: input.sourceChainId,
-        destinationChainId,
-        tracks: orchestration.tracks,
-        handoffs: orchestration.handoffs,
-    });
-    const sourceResult = orchestration.sourceResult;
-    const destinationResult = orchestration.destinationResult;
-    if (sourceResult) {
-        sourceResult.crossChain = crossChainReceipt;
-    }
-    if (destinationResult) {
-        destinationResult.crossChain = crossChainReceipt;
-    }
-    if (orchestration.pending && !store) {
-        throw new Error("Cannot leave a run in waiting state without persistence. Disable --no-state.");
-    }
-    if (store) {
-        if (sourceResult) {
-            await store.save(input.sourceSpell.id, sourceResult.finalState);
-            const sourceProvenance = {
-                ...buildRuntimeProvenanceManifest({
-                    runtimeMode: runtimeFlow,
-                    chainId: input.sourceChainId,
-                    policy: input.dataPolicy,
-                    replay: input.replayResolution,
-                    params: input.params,
-                    blockNumber: await safeGetBlockNumber(sourceProvider),
-                    rpcUrl: sourceProvider.rpcUrl,
-                }),
-                cross_chain: manifest,
-            };
-            await store.addRun(input.sourceSpell.id, createRunRecord(sourceResult, sourceProvenance));
-            await store.saveLedger(input.sourceSpell.id, runId, appendLifecycleLedgerEntries(sourceResult.ledgerEvents, lifecycleEvents, runId, input.sourceSpell.id));
-        }
-        if (destinationResult) {
-            await store.save(destinationSpell.id, destinationResult.finalState);
-            const destinationProvenance = {
-                ...buildRuntimeProvenanceManifest({
-                    runtimeMode: runtimeFlow,
-                    chainId: destinationChainId,
-                    policy: input.dataPolicy,
-                    replay: input.replayResolution,
-                    params: input.params,
-                    blockNumber: await safeGetBlockNumber(destinationProvider),
-                    rpcUrl: destinationProvider.rpcUrl,
-                }),
-                cross_chain: manifest,
-            };
-            await store.addRun(destinationSpell.id, createRunRecord(destinationResult, destinationProvenance));
-            await store.saveLedger(destinationSpell.id, runId, destinationResult.ledgerEvents);
-        }
-        await persistCrossChainState(store, {
-            runId,
-            tracks: orchestration.tracks,
-            handoffs: orchestration.handoffs,
-            sourceSpellId: input.sourceSpell.id,
-            destinationSpellId: destinationSpell.id,
-            sourceResult,
-            destinationResult,
-        });
-    }
-    spinner.stop();
-    const mergedResult = destinationResult ?? sourceResult;
-    if (!mergedResult) {
-        throw new Error("Cross-chain orchestration returned no execution results.");
-    }
-    if (input.options.json) {
-        console.log(stringifyJson({
-            success: orchestration.success,
-            pending: orchestration.pending,
-            runId,
-            crossChain: crossChainReceipt,
-            source: sourceResult
-                ? {
-                    success: sourceResult.success,
-                    error: sourceResult.structuredError,
-                    receipt: sourceResult.receipt,
-                }
-                : undefined,
-            destination: destinationResult
-                ? {
-                    success: destinationResult.success,
-                    error: destinationResult.structuredError,
-                    receipt: destinationResult.receipt,
-                }
-                : undefined,
-        }));
+    console.error();
+    if (options.json) {
+        console.error(stringifyJson(payload));
     }
     else {
-        console.log();
-        console.log(chalk.cyan("🔀 Cross-Chain Run:"));
-        console.log(`  ${chalk.dim("Run ID:")} ${runId}`);
-        console.log(`  ${chalk.dim("Source:")} ${input.sourceSpell.meta.name} (${input.sourceChainId}) -> ${chalk.dim("Destination:")} ${destinationSpell.meta.name} (${destinationChainId})`);
-        console.log(`  ${chalk.dim("Watch:")} ${input.options.watch === true ? "Yes" : "No"}`);
-        console.log(`  ${chalk.dim("Status:")} ${orchestration.pending ? chalk.yellow("waiting") : orchestration.success ? chalk.green("completed") : chalk.red("failed")}`);
-        for (const track of orchestration.tracks) {
-            const trackStatus = track.status === "completed"
-                ? chalk.green(track.status)
-                : track.status === "failed"
-                    ? chalk.red(track.status)
-                    : track.status === "waiting"
-                        ? chalk.yellow(track.status)
-                        : chalk.dim(track.status);
-            console.log(`  ${chalk.dim(`track:${track.trackId}`)} ${trackStatus} chain=${track.chainId} spell=${track.spellId}`);
-            if (track.error) {
-                console.log(`    ${chalk.red(track.error)}`);
-            }
-        }
-        for (const handoff of orchestration.handoffs) {
-            console.log(`  ${chalk.dim(`handoff:${handoff.handoffId}`)} ${handoff.status} submitted=${handoff.submittedAmount.toString()} settled=${handoff.settledAmount?.toString() ?? "n/a"}`);
-        }
-        if (orchestration.pending) {
-            console.log();
-            console.log(chalk.yellow("Run is waiting for handoff settlement. Resume with:"));
-            console.log(chalk.yellow(`  grimoire resume ${runId} --watch`));
-        }
-    }
-    if (!orchestration.success && !orchestration.pending) {
-        process.exit(1);
-    }
-}
-async function safeGetBlockNumber(provider) {
-    try {
-        return await provider.getBlockNumber();
-    }
-    catch {
-        return undefined;
-    }
-}
-async function resolveKeyConfig(options, spinner) {
-    const hasExplicitKey = !!(options.privateKey || options.mnemonic || options.keystore);
-    const hasEnvKey = !!(options.keyEnv && process.env[options.keyEnv]);
-    const hasDefaultKeystore = !hasExplicitKey && !hasEnvKey && existsSync(DEFAULT_KEYSTORE_PATH);
-    if (options.privateKey) {
-        return { type: "raw", source: options.privateKey };
-    }
-    if (options.keyEnv && process.env[options.keyEnv]) {
-        return { type: "env", source: options.keyEnv };
-    }
-    if (options.mnemonic) {
-        return { type: "mnemonic", source: options.mnemonic };
-    }
-    if (hasDefaultKeystore || options.keystore) {
-        const keystorePath = options.keystore ?? DEFAULT_KEYSTORE_PATH;
-        if (!existsSync(keystorePath)) {
-            spinner.fail(chalk.red(`No key provided and no keystore found at ${keystorePath}`));
-            console.log(chalk.dim("  Run 'grimoire wallet generate' to create one."));
-            process.exit(1);
-            throw new Error("unreachable");
-        }
-        const password = await resolveKeystorePassword(options, spinner);
-        if (!password) {
-            process.exit(1);
-            throw new Error("unreachable");
-        }
-        const keystoreJson = readFileSync(keystorePath, "utf-8");
-        return { type: "keystore", source: keystoreJson, password };
-    }
-    throw new Error("Execution mode requires wallet credentials, but no key source was provided");
-}
-function resolveVaultAddress(explicitVault, fallbackWalletAddress) {
-    if (explicitVault && explicitVault.length > 0) {
-        return explicitVault;
-    }
-    if (fallbackWalletAddress && fallbackWalletAddress.length > 0) {
-        return fallbackWalletAddress;
-    }
-    return "0x0000000000000000000000000000000000000000";
-}
-function parseRequiredNumber(value, flag) {
-    if (!value) {
-        throw new Error(`${flag} is required in cross-chain mode`);
-    }
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isFinite(parsed) || parsed <= 0) {
-        throw new Error(`${flag} must be a positive integer`);
-    }
-    return parsed;
-}
-function resolveRpcUrlFromOption(chainId, value) {
-    const parsed = parseRpcUrlMappings(value);
-    return resolveRpcUrlForChain(chainId, parsed);
-}
-function isMissingNodeSqliteBackend(error) {
-    if (!(error instanceof Error))
-        return false;
-    return error.message.includes("SqliteStateStore requires bun:sqlite (Bun) or better-sqlite3 (Node)");
-}
-function appendLifecycleLedgerEntries(entries, lifecycleEvents, runId, spellId) {
-    if (lifecycleEvents.length === 0) {
-        return entries;
-    }
-    const start = entries.length;
-    const extras = lifecycleEvents.map((event, index) => ({
-        id: `evt_cc_${String(start + index).padStart(3, "0")}`,
-        timestamp: Date.now(),
-        runId,
-        spellId,
-        event,
-    }));
-    return [...entries, ...extras];
-}
-async function persistCrossChainState(store, input) {
-    const nowIso = new Date().toISOString();
-    for (const track of input.tracks) {
-        const row = {
-            runId: input.runId,
-            trackId: track.trackId,
-            role: track.role,
-            spellId: track.spellId,
-            chainId: track.chainId,
-            status: track.status,
-            lastStepId: track.lastStepId,
-            error: track.error,
-            updatedAt: nowIso,
-        };
-        await store.upsertRunTrack(row);
-    }
-    for (const handoff of input.handoffs) {
-        const row = {
-            runId: input.runId,
-            handoffId: handoff.handoffId,
-            sourceTrackId: handoff.sourceTrackId,
-            destinationTrackId: handoff.destinationTrackId,
-            sourceStepId: handoff.sourceStepId,
-            originChainId: handoff.originChainId,
-            destinationChainId: handoff.destinationChainId,
-            asset: handoff.asset,
-            submittedAmount: handoff.submittedAmount.toString(),
-            settledAmount: handoff.settledAmount?.toString(),
-            status: handoff.status,
-            reference: handoff.reference,
-            originTxHash: handoff.originTxHash,
-            reason: handoff.reason,
-            createdAt: nowIso,
-            updatedAt: nowIso,
-            expiresAt: handoff.status === "expired" ? nowIso : undefined,
-        };
-        await store.upsertRunHandoff(row);
-    }
-    const sourceSteps = collectStepStatuses(input.sourceResult, "source", input.runId);
-    for (const step of sourceSteps) {
-        await store.upsertRunStepResult(step);
-    }
-    const destinationSteps = collectStepStatuses(input.destinationResult, "destination", input.runId);
-    for (const step of destinationSteps) {
-        await store.upsertRunStepResult(step);
-    }
-}
-function collectStepStatuses(result, trackId, runId) {
-    if (!result?.receipt) {
-        return [];
-    }
-    const nowIso = new Date().toISOString();
-    const byStep = new Map();
-    for (const planned of result.receipt.plannedActions) {
-        byStep.set(planned.stepId, {
-            runId,
-            trackId,
-            stepId: planned.stepId,
-            status: "pending",
-            idempotencyKey: `${runId}:${trackId}:${planned.stepId}`,
-            updatedAt: nowIso,
-        });
-    }
-    for (const tx of result.commit?.transactions ?? []) {
-        const existing = byStep.get(tx.stepId);
-        if (!existing)
-            continue;
-        existing.status = tx.success ? "confirmed" : "failed";
-        existing.reference = tx.hash;
-        existing.error = tx.error;
-    }
-    if (result.success && !result.commit) {
-        for (const step of byStep.values()) {
-            step.status = "confirmed";
-        }
+        console.error(formatRunReportText(report));
     }
     if (!result.success) {
-        for (const step of byStep.values()) {
-            if (step.status !== "confirmed") {
-                step.status = "failed";
-            }
-        }
-    }
-    return [...byStep.values()];
-}
-async function resolveKeystorePassword(options, spinner) {
-    const envName = options.passwordEnv ?? "KEYSTORE_PASSWORD";
-    const envValue = process.env[envName];
-    if (envValue) {
-        return envValue;
-    }
-    if (process.stdin.isTTY) {
-        spinner.stop();
-        const password = await promptPassword("Keystore password: ");
-        spinner.start("Setting up wallet...");
-        return password;
+        throw new Error("Cast failed");
     }
-    spinner.fail(chalk.red(`No password available. Set ${envName} or run interactively.`));
-    process.exit(1);
-    return null;
-}
-async function promptPassword(message) {
-    return new Promise((resolve) => {
-        process.stdout.write(message);
-        const silentOutput = new Writable({
-            write(_chunk, _encoding, cb) {
-                cb();
-            },
-        });
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: silentOutput,
-            terminal: true,
-        });
-        rl.question("", (answer) => {
-            rl.close();
-            process.stdout.write("\n");
-            resolve(answer);
-        });
-    });
-}
-async function confirmPrompt(message) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        rl.question(message, (answer) => {
-            rl.close();
-            const normalized = answer.toLowerCase().trim();
-            resolve(normalized === "yes" || normalized === "y");
-        });
-    });
-}
-function resolveNoState(options) {
-    if (typeof options.noState === "boolean")
-        return options.noState;
-    if (options.state === false)
-        return true;
-    return false;
-}
-function stringifyJson(value) {
-    return JSON.stringify(value, (_key, innerValue) => (typeof innerValue === "bigint" ? innerValue.toString() : innerValue), 2);
+    return payload;
 }
 //# sourceMappingURL=cast.js.map