balchemy 0.1.22 → 0.1.24

package/dist/tui/AgentBridge.js

@@ -4,7 +4,7 @@ import { AgentLoop, connectMcp } from "@balchemyai/agent-sdk";
 import { ChatAgent } from "./ChatAgent.js";
 import { buildSetupRequiredMessage, getInitialSetupStep, isSetupReady, parseNetworkSelection, parseSetupStatusSnapshot, } from "./setup-guidance.js";
 import { buildStrategyUpdateArgs } from "./session-sync.js";
-import { loadAgent } from "../agent-store.js";
+import { loadAgent, saveAgent } from "../agent-store.js";
 /** Truncate verbose API errors (429 JSON blobs, stack traces) to a readable one-liner. */
 function truncateError(raw) {
     // Extract HTTP status code if present
@@ -53,6 +53,23 @@ function parseJsonObject(text) {
         return null;
     }
 }
+function parseJsonObjectLoose(text) {
+    const direct = parseJsonObject(text);
+    if (direct)
+        return direct;
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fenced?.[1]) {
+        const parsed = parseJsonObject(fenced[1].trim());
+        if (parsed)
+            return parsed;
+    }
+    const first = text.indexOf("{");
+    const last = text.lastIndexOf("}");
+    if (first >= 0 && last > first) {
+        return parseJsonObject(text.slice(first, last + 1));
+    }
+    return null;
+}
 function asRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
@@ -108,6 +125,25 @@ function mergeWallets(...groups) {
     }
     return wallets;
 }
+function mergeLatestWallets(...groups) {
+    const latest = new Map();
+    for (const group of groups) {
+        for (const wallet of group) {
+            latest.set(wallet.chain, wallet);
+        }
+    }
+    const ordered = [];
+    const solana = latest.get("solana");
+    const base = latest.get("base");
+    if (solana)
+        ordered.push(solana);
+    if (base)
+        ordered.push(base);
+    return ordered;
+}
+function walletAddressLabel(chain) {
+    return chain === "solana" ? "Solana trading wallet" : "Base trading wallet";
+}
 function readRecords(value) {
     if (!Array.isArray(value))
         return [];
@@ -278,6 +314,67 @@ function parseTradeLimits(value) {
         ...(maxTradeUsd !== undefined && Number.isFinite(maxTradeUsd) ? { maxTradeUsd } : {}),
     };
 }
+function readStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => typeof item === "string" && item.trim() ? [item.trim()] : []);
+}
+function parseStrategyReviewResponse(text) {
+    const parsed = parseJsonObjectLoose(text);
+    if (!parsed)
+        return null;
+    const ready = parsed.ready === true;
+    const summary = firstString(parsed.summary, parsed.strategy, parsed.normalizedStrategy) ?? "";
+    const followUp = firstString(parsed.followUp, parsed.follow_up, parsed.question) ?? "";
+    const missing = readStringArray(parsed.missing);
+    const limits = parseTradeLimits(summary);
+    const maxTradeSol = firstNumber(parsed, ["maxTradeSol", "max_trade_sol"]) ?? limits.maxTradeSol;
+    const maxTradeUsd = firstNumber(parsed, ["maxTradeUsd", "max_trade_usd"]) ?? limits.maxTradeUsd;
+    return {
+        ready,
+        summary,
+        followUp,
+        missing,
+        ...(maxTradeSol !== undefined ? { maxTradeSol } : {}),
+        ...(maxTradeUsd !== undefined ? { maxTradeUsd } : {}),
+    };
+}
+function fallbackStrategyReview(chain, notes) {
+    const summary = notes.join("\n").trim();
+    const limits = parseTradeLimits(summary);
+    const lower = summary.toLowerCase();
+    const missing = [];
+    if (chain === "solana" && limits.maxTradeSol === undefined) {
+        missing.push("max SOL per trade");
+    }
+    if (chain === "base" && limits.maxTradeUsd === undefined) {
+        missing.push("max USD/USDC per trade");
+    }
+    if (!/(entry|filter|hacim|volume|mcap|market cap|holder|liquidity|giris|giriş)/i.test(summary)) {
+        missing.push("entry filters");
+    }
+    if (!/(stop|loss|zarar|sl\b)/i.test(lower)) {
+        missing.push("stop loss");
+    }
+    if (!/(take profit|profit|kar|sat|sell|tp\b|x\b)/i.test(lower)) {
+        missing.push("take profit");
+    }
+    if (!/(max.*position|position|pozisyon|concurrent|ayn[ıi] anda)/i.test(lower)) {
+        missing.push("max open positions");
+    }
+    if (!/(avoid|kaçın|kacin|yasak|alma|blacklist|tokenleri|categories|kategori)/i.test(lower)) {
+        missing.push("avoid rules");
+    }
+    return {
+        ready: summary.length >= 20 && missing.length === 0,
+        summary,
+        missing,
+        followUp: missing.length > 0
+            ? `I still need this before live setup: ${missing.join(", ")}. Send only the missing parts; I will merge them.`
+            : "",
+        ...limits,
+    };
+}
 function formatChains(chains) {
     return chains.map((chain) => chain === "solana" ? "Solana" : "Base").join(" + ");
 }
@@ -319,9 +416,11 @@ export class AgentBridge {
     pendingLoopConfig = null;
     setupPollTimer = null;
     setupFlow = null;
+    knownWallets = [];
     constructor(config, setters) {
         this.config = config;
         this.setters = setters;
+        this.knownWallets = this.loadStoredWallets();
         // Replay-protected fetch for MCP calls
         this.replayFetch = async (url, init) => {
             const headers = new Headers(init?.headers);
@@ -435,6 +534,7 @@ export class AgentBridge {
             provider: resolveProviderLabel(this.config.llmProvider, this.config.llmBaseUrl),
             model: this.config.llmModel,
         }));
+        this.syncKnownWalletsToStatus();
         // Input is ready now. Setup must be deterministic; do not let an LLM drive it.
         if (setupComplete) {
             void this.greet(true);
@@ -452,7 +552,7 @@ export class AgentBridge {
         }
         try {
             const prompt = "Check my portfolio and status, then greet me. Tell me my balance, wallets, and current strategy. Keep it brief and do not narrate tool calls.";
-            const reply = await this.chatAgent.chat(prompt, (name, result) => {
+            const reply = await this.chatAgent.chat(this.withRuntimeContext(prompt), (name, result) => {
                 this.applyToolResult(name, result);
                 if (name !== "setup_agent") {
                     this.addSystemMessage(`Tool: ${name}`);
@@ -498,7 +598,7 @@ export class AgentBridge {
         if (!this.chatAgent)
             return;
         try {
-            const reply = await this.chatAgent.chat(text, (name, result) => {
+            const reply = await this.chatAgent.chat(this.withRuntimeContext(text), (name, result) => {
                 this.applyToolResult(name, result);
                 this.addSystemMessage(`Tool: ${name}`);
             }, (preview) => this.setters.confirmTrade(preview));
@@ -542,6 +642,8 @@ export class AgentBridge {
         const step = getInitialSetupStep(snapshot);
         this.setupFlow = {
             step,
+            rootWalletBound: snapshot.developerWalletBound === true,
+            ...(snapshot.rootWalletKind ? { rootWalletKind: snapshot.rootWalletKind } : {}),
             ...(snapshot.selectedChains && snapshot.selectedChains.length > 0 ? { selectedChains: snapshot.selectedChains } : {}),
         };
         this.addAgentMessage(`${buildSetupRequiredMessage(snapshot)}\n\n${this.setupPromptFor(this.setupFlow.step)}`);
@@ -555,19 +657,85 @@ export class AgentBridge {
             case "networks":
                 return "Which networks should this agent trade on: Solana, Base, or both?";
             case "solana-recovery-wallet":
-                return "Paste your Solana recovery/withdrawal wallet address. This is where SOL/SPL withdrawals go, and it is separate from the Solana trading wallet I create for execution.";
+                return "Paste your Solana developer/recovery wallet address. For Solana-only setup this becomes the root master-key wallet; for Base+Solana it is the Solana withdrawal/recovery wallet. It is separate from the Solana trading wallet I create for execution.";
             case "solana-recovery-wallet-confirm":
-                return "Paste the same Solana recovery/withdrawal wallet again to confirm it.";
+                return "Paste the same Solana wallet again to confirm it.";
             case "slippage":
                 return "Set slippage in percent or bps. Examples: 1% = 100 bps, 3% = 300 bps, 5% = 500 bps.";
             case "strategy":
-                return "Send the hard limits and strategy for this chain. Include max trade size, entry filters, stop loss, take profit, max positions, and tokens/categories to avoid.";
+                return "Describe the strategy in natural language. I will review it with AI, ask for missing risk details, and only then ask you to confirm.";
             case "strategy-confirm":
                 return "Confirm with 'yes'/'evet', or say 'no'/'hayir' to rewrite the strategy.";
             case "subscriptions":
                 return "Create monitoring subscriptions now? For Solana new launches I can enable launch monitoring. Answer yes/evet or no/hayir.";
         }
     }
+    setupPromptForStrategyChain(chain) {
+        const maxTrade = chain === "solana"
+            ? "max SOL per trade"
+            : "max USD/USDC per trade";
+        return [
+            `${chainTitle(chain)} strategy:`,
+            "Describe what you want the agent to trade and how strict it must be.",
+            `Include ${maxTrade}, entry filters, stop loss, take profit, max open positions, and avoid rules.`,
+            "You can write it messy; I will ask follow-ups if anything critical is missing.",
+        ].join("\n");
+    }
+    async createTradingWalletsForSetup(chains) {
+        const walletLines = [];
+        for (const chain of chains) {
+            const structured = await this.callSetupAgent({ action: "create_wallet", chain });
+            const wallet = readWallet({ ...structured, chain });
+            if (wallet)
+                this.upsertWallet(wallet);
+            const address = wallet?.address ?? firstString(structured.address, asRecord(structured.wallet)?.address);
+            walletLines.push(`${chainTitle(chain)} trading wallet: ${address ?? "(created)"}`);
+        }
+        return walletLines;
+    }
+    selectedChainsForSetup(flow) {
+        if (flow.selectedChains && flow.selectedChains.length > 0) {
+            return flow.selectedChains;
+        }
+        return [...new Set(this.knownWallets.map((wallet) => wallet.chain))];
+    }
+    async reviewStrategyWithAi(chain, selectedChains, notes) {
+        const fallback = fallbackStrategyReview(chain, notes);
+        if (!this.chatAgent)
+            return fallback;
+        const unit = chain === "solana" ? "SOL" : "USD/USDC";
+        const systemPrompt = [
+            "You are the strategy-coaching layer inside Balchemy CLI setup.",
+            "You do not call tools. You only decide whether the user's strategy is safe enough to configure.",
+            "Return strict JSON only. No markdown.",
+            "Required JSON shape:",
+            '{"ready":boolean,"summary":"string","missing":["string"],"followUp":"string","maxTradeSol":number|null,"maxTradeUsd":number|null}',
+            `Current chain: ${chainTitle(chain)}. Required max trade unit: ${unit}.`,
+            `Selected chains: ${formatChains(selectedChains)}.`,
+            "A ready strategy must include max trade size, entry filters, stop loss, take profit, max open positions, and avoid/blacklist rules.",
+            "If anything critical is missing, ready=false and followUp must ask only for the missing items in the same language as the user.",
+            "If ready=true, summary must be a faithful normalized version of all user notes with chain-specific limits preserved.",
+        ].join("\n");
+        const userMessage = [
+            `Chain: ${chainTitle(chain)}`,
+            "User notes:",
+            notes.map((note, index) => `${index + 1}. ${note}`).join("\n"),
+        ].join("\n\n");
+        try {
+            const response = await this.chatAgent.completeText(systemPrompt, userMessage);
+            const parsed = parseStrategyReviewResponse(response);
+            if (!parsed)
+                return fallback;
+            if (!parsed.ready && !parsed.followUp)
+                return fallback;
+            if (parsed.ready && parsed.summary.trim().length < 20)
+                return fallback;
+            return parsed;
+        }
+        catch (_error) {
+            return fallback;
+        }
+    }
     async handleSetupInput(text) {
         const flow = this.setupFlow;
         if (!flow)
@@ -586,7 +754,11 @@ export class AgentBridge {
             if (flow.step === "developer-wallet-confirm") {
                 const wallet = text.trim();
                 if (!flow.developerWallet || wallet.toLowerCase() !== flow.developerWallet.toLowerCase()) {
-                    this.setupFlow = { step: "developer-wallet" };
+                    this.setupFlow = {
+                        ...flow,
+                        step: "developer-wallet",
+                        developerWallet: undefined,
+                    };
                     this.addAgentMessage("The confirmation did not match. Start again by pasting the Base/EVM 0x developer wallet.");
                     return;
                 }
@@ -596,10 +768,50 @@ export class AgentBridge {
                     walletAddressConfirm: wallet,
                 });
                 const masterKey = extractMasterKey(structured);
-                this.setupFlow = { step: "networks" };
+                if (masterKey) {
+                    this.persistMasterKey(masterKey);
+                }
+                if (flow.selectedChains && flow.selectedChains.length > 0) {
+                    this.setupFlow = {
+                        ...flow,
+                        step: "networks",
+                        rootWalletBound: true,
+                        rootWalletKind: "evm",
+                    };
+                    const walletLines = await this.createTradingWalletsForSetup(flow.selectedChains);
+                    const needsSolanaWallet = flow.selectedChains.includes("solana") && !flow.solanaRecoveryWallet;
+                    this.setupFlow = {
+                        ...flow,
+                        step: needsSolanaWallet ? "solana-recovery-wallet" : "slippage",
+                        rootWalletBound: true,
+                        rootWalletKind: "evm",
+                    };
+                    this.addAgentMessage(`${masterKey ? `Developer wallet bound.
+
+Master key saved encrypted locally and shown here so you can copy it externally:
+${masterKey}
+
+It is shown once in real environments.` : "Developer wallet bound."}
+
+Copyable trading wallet addresses:
+${walletLines.join("\n")}
+
+${this.setupPromptFor(needsSolanaWallet ? "solana-recovery-wallet" : "slippage")}`);
+                    return;
+                }
+                this.setupFlow = { step: "networks", rootWalletBound: true, rootWalletKind: "evm" };
                 this.addAgentMessage(masterKey
-                    ? `Developer wallet bound.\n\nCopy and store this master key now:\n${masterKey}\n\nIt is shown once in real environments.\n\n${this.setupPromptFor("networks")}`
-                    : `Developer wallet bound.\n\n${this.setupPromptFor("networks")}`);
+                    ? `Developer wallet bound.
+
+Master key saved encrypted locally and shown here so you can copy it externally:
+${masterKey}
+
+It is shown once in real environments.
+
+${this.setupPromptFor("networks")}`
+                    : `Developer wallet bound.
+
+${this.setupPromptFor("networks")}`);
                 return;
             }
             if (flow.step === "networks") {
@@ -608,17 +820,37 @@ export class AgentBridge {
                     this.addAgentMessage("Choose Solana, Base, or both.");
                     return;
                 }
-                const walletLines = [];
-                for (const chain of chains) {
-                    const structured = await this.callSetupAgent({ action: "create_wallet", chain });
-                    const address = firstString(structured.address, asRecord(structured.wallet)?.address);
-                    walletLines.push(`${chainTitle(chain)} trading wallet: ${address ?? "(created)"}`);
+                if (!flow.rootWalletBound) {
+                    if (chains.includes("base")) {
+                        this.setupFlow = { ...flow, step: "developer-wallet", selectedChains: chains };
+                        this.addAgentMessage(`Trading networks selected: ${formatChains(chains)}.
+
+${this.setupPromptFor("developer-wallet")}`);
+                        return;
+                    }
+                    this.setupFlow = { ...flow, step: "solana-recovery-wallet", selectedChains: chains };
+                    this.addAgentMessage(`Trading networks selected: ${formatChains(chains)}.
+
+${this.setupPromptFor("solana-recovery-wallet")}`);
+                    return;
+                }
+                if (flow.rootWalletKind === "solana" && chains.includes("base")) {
+                    this.addAgentMessage("This agent is bound with a Solana-only root wallet. Base trading requires a Base/EVM developer wallet, so choose Solana for this setup or start a new Base/both setup.");
+                    return;
                 }
+                const walletLines = await this.createTradingWalletsForSetup(chains);
+                const needsSolanaWallet = chains.includes("solana") && !flow.solanaRecoveryWallet;
                 this.setupFlow = {
-                    step: chains.includes("solana") ? "solana-recovery-wallet" : "slippage",
+                    ...flow,
+                    step: needsSolanaWallet ? "solana-recovery-wallet" : "slippage",
                     selectedChains: chains,
                 };
-                this.addAgentMessage(`Trading networks configured: ${formatChains(chains)}.\n\nCopyable trading wallet addresses:\n${walletLines.join("\n")}\n\n${this.setupPromptFor(chains.includes("solana") ? "solana-recovery-wallet" : "slippage")}`);
+                this.addAgentMessage(`Trading networks configured: ${formatChains(chains)}.
+
+Copyable trading wallet addresses:
+${walletLines.join("\n")}
+
+${this.setupPromptFor(needsSolanaWallet ? "solana-recovery-wallet" : "slippage")}`);
                 return;
             }
             if (flow.step === "solana-recovery-wallet") {
@@ -637,11 +869,55 @@ export class AgentBridge {
                     this.setupFlow = {
                         step: "solana-recovery-wallet",
                         ...(flow.developerWallet ? { developerWallet: flow.developerWallet } : {}),
+                        ...(flow.rootWalletBound !== undefined ? { rootWalletBound: flow.rootWalletBound } : {}),
+                        ...(flow.rootWalletKind ? { rootWalletKind: flow.rootWalletKind } : {}),
                         ...(flow.selectedChains ? { selectedChains: flow.selectedChains } : {}),
                     };
                     this.addAgentMessage("The Solana wallet confirmation did not match. Paste the Solana recovery/withdrawal wallet again.");
                     return;
                 }
+                if (!flow.rootWalletBound) {
+                    const structured = await this.callSetupAgent({
+                        action: "bind_solana_root_wallet",
+                        solanaWalletAddress: flow.solanaRecoveryWallet,
+                        solanaWalletAddressConfirm: wallet,
+                    });
+                    const masterKey = extractMasterKey(structured);
+                    if (masterKey) {
+                        this.persistMasterKey(masterKey);
+                    }
+                    const selectedChains = flow.selectedChains && flow.selectedChains.length > 0 ? flow.selectedChains : ["solana"];
+                    this.setupFlow = {
+                        ...flow,
+                        step: "networks",
+                        solanaRecoveryWallet: wallet,
+                        rootWalletBound: true,
+                        rootWalletKind: "solana",
+                        selectedChains,
+                    };
+                    const walletLines = await this.createTradingWalletsForSetup(selectedChains);
+                    this.setupFlow = {
+                        ...flow,
+                        step: "slippage",
+                        solanaRecoveryWallet: wallet,
+                        rootWalletBound: true,
+                        rootWalletKind: "solana",
+                        selectedChains,
+                    };
+                    this.addAgentMessage(`Solana developer/recovery wallet confirmed:
+${wallet}
+
+${masterKey ? `Master key saved encrypted locally and shown here so you can copy it externally:
+${masterKey}
+
+It is shown once in real environments.
+
+` : ""}Copyable trading wallet addresses:
+${walletLines.join("\n")}
+
+${this.setupPromptFor("slippage")}`);
+                    return;
+                }
                 try {
                     await this.callSetupAgent({
                         action: "bind_solana_developer_wallet",
@@ -653,7 +929,10 @@ export class AgentBridge {
                     this.addSystemMessage(`Solana recovery wallet stored locally for this setup. MCP did not bind it directly: ${err instanceof Error ? err.message : String(err)}`);
                 }
                 this.setupFlow = { ...flow, step: "slippage", solanaRecoveryWallet: wallet };
-                this.addAgentMessage(`Solana recovery/withdrawal wallet confirmed:\n${wallet}\n\n${this.setupPromptFor("slippage")}`);
+                this.addAgentMessage(`Solana recovery/withdrawal wallet confirmed:
+${wallet}
+
+${this.setupPromptFor("slippage")}`);
                 return;
             }
             if (flow.step === "slippage") {
@@ -663,33 +942,83 @@ export class AgentBridge {
                     return;
                 }
                 await this.callSetupAgent({ action: "configure_slippage", slippageBps: bps });
-                const selectedChains = flow.selectedChains ?? ["solana"];
+                const selectedChains = this.selectedChainsForSetup(flow);
+                if (selectedChains.length === 0) {
+                    this.setupFlow = { ...flow, step: "networks" };
+                    this.addAgentMessage(`I need the selected trading networks before strategy setup.\n\n${this.setupPromptFor("networks")}`);
+                    return;
+                }
                 const currentStrategyChain = nextStrategyChain(selectedChains, {}) ?? selectedChains[0];
                 this.setupFlow = { ...flow, step: "strategy", slippageBps: bps, currentStrategyChain, chainStrategies: {} };
-                this.addAgentMessage(`Slippage set to ${bps} bps.\n\n${chainTitle(currentStrategyChain)} strategy:\n${this.setupPromptFor("strategy")}`);
+                this.addAgentMessage(`Slippage set to ${bps} bps.\n\n${this.setupPromptForStrategyChain(currentStrategyChain)}`);
                 return;
             }
             if (flow.step === "strategy") {
-                const strategyText = text.trim();
-                if (strategyText.length < 20) {
-                    this.addAgentMessage("The strategy is too short. Include limits, entries, exits, max positions, and avoid rules.");
+                const strategyNote = text.trim();
+                const selectedChainsForFlow = this.selectedChainsForSetup(flow);
+                const chain = flow.currentStrategyChain ?? selectedChainsForFlow[0];
+                if (!chain) {
+                    this.setupFlow = { ...flow, step: "networks" };
+                    this.addAgentMessage(`I need the selected trading networks before strategy setup.\n\n${this.setupPromptFor("networks")}`);
+                    return;
+                }
+                if (strategyNote.length < 8) {
+                    this.addAgentMessage("That is too short for live setup. Add trade size, entry filters, exits, max positions, or avoid rules.");
+                    return;
+                }
+                const previousNotes = flow.strategyNotes?.[chain] ?? [];
+                const notes = [...previousNotes, strategyNote];
+                const selectedChains = selectedChainsForFlow.length > 0 ? selectedChainsForFlow : [chain];
+                const strategyNotes = {
+                    ...(flow.strategyNotes ?? {}),
+                    [chain]: notes,
+                };
+                this.setupFlow = { ...flow, strategyNotes };
+                const review = await this.reviewStrategyWithAi(chain, selectedChains, notes);
+                if (!review.ready) {
+                    const missingLine = review.missing.length > 0 ? `\n\nMissing: ${review.missing.join(", ")}` : "";
+                    this.addAgentMessage(`${review.followUp || "I need a little more detail before this can go live."}${missingLine}`);
                     return;
                 }
+                const strategyText = review.summary.trim() || notes.join("\n");
+                const parsedLimits = parseTradeLimits(strategyText);
+                const maxTradeSol = chain === "solana"
+                    ? review.maxTradeSol ?? parsedLimits.maxTradeSol ?? flow.maxTradeSol
+                    : flow.maxTradeSol;
+                const maxTradeUsd = chain === "base"
+                    ? review.maxTradeUsd ?? parsedLimits.maxTradeUsd ?? flow.maxTradeUsd
+                    : flow.maxTradeUsd;
                 const chainStrategies = {
                     ...(flow.chainStrategies ?? {}),
-                    ...(flow.currentStrategyChain ? { [flow.currentStrategyChain]: strategyText } : {}),
+                    [chain]: strategyText,
                 };
-                const selectedChains = flow.selectedChains ?? (flow.currentStrategyChain ? [flow.currentStrategyChain] : ["solana"]);
                 const nextChain = nextStrategyChain(selectedChains, chainStrategies);
                 if (nextChain) {
-                    this.setupFlow = { ...flow, chainStrategies, currentStrategyChain: nextChain };
-                    this.addAgentMessage(`${chainTitle(flow.currentStrategyChain ?? selectedChains[0])} strategy saved.\n\n${chainTitle(nextChain)} strategy:\n${this.setupPromptFor("strategy")}`);
+                    this.setupFlow = {
+                        ...flow,
+                        chainStrategies,
+                        currentStrategyChain: nextChain,
+                        strategyNotes,
+                        ...(maxTradeSol !== undefined ? { maxTradeSol } : {}),
+                        ...(maxTradeUsd !== undefined ? { maxTradeUsd } : {}),
+                    };
+                    this.addAgentMessage(`${chainTitle(chain)} strategy drafted with AI review.\n\n${this.setupPromptForStrategyChain(nextChain)}`);
                     return;
                 }
                 const combinedStrategy = buildCombinedStrategy({ ...flow, chainStrategies });
-                const limits = parseTradeLimits(combinedStrategy);
-                this.setupFlow = { ...flow, ...limits, chainStrategies, step: "strategy-confirm", strategyText: combinedStrategy };
-                this.addAgentMessage(`Review before live configuration:\n\n${combinedStrategy}\n\nMax SOL/trade: ${limits.maxTradeSol ?? "not specified"}\nMax USD/trade: ${limits.maxTradeUsd ?? "not specified"}\n\n${this.setupPromptFor("strategy-confirm")}`);
+                const combinedLimits = parseTradeLimits(combinedStrategy);
+                const finalMaxTradeSol = maxTradeSol ?? combinedLimits.maxTradeSol;
+                const finalMaxTradeUsd = maxTradeUsd ?? combinedLimits.maxTradeUsd;
+                this.setupFlow = {
+                    ...flow,
+                    chainStrategies,
+                    strategyNotes,
+                    step: "strategy-confirm",
+                    strategyText: combinedStrategy,
+                    ...(finalMaxTradeSol !== undefined ? { maxTradeSol: finalMaxTradeSol } : {}),
+                    ...(finalMaxTradeUsd !== undefined ? { maxTradeUsd: finalMaxTradeUsd } : {}),
+                };
+                this.addAgentMessage(`AI-reviewed strategy draft:\n\n${combinedStrategy}\n\nMax SOL/trade: ${finalMaxTradeSol ?? "not specified"}\nMax USD/trade: ${finalMaxTradeUsd ?? "not specified"}\n\n${this.setupPromptFor("strategy-confirm")}`);
                 return;
             }
             if (flow.step === "strategy-confirm") {
@@ -698,12 +1027,14 @@ export class AgentBridge {
                         step: "strategy",
                         ...(flow.developerWallet ? { developerWallet: flow.developerWallet } : {}),
                         ...(flow.solanaRecoveryWallet ? { solanaRecoveryWallet: flow.solanaRecoveryWallet } : {}),
+                        ...(flow.rootWalletBound !== undefined ? { rootWalletBound: flow.rootWalletBound } : {}),
+                        ...(flow.rootWalletKind ? { rootWalletKind: flow.rootWalletKind } : {}),
                         ...(flow.selectedChains ? { selectedChains: flow.selectedChains } : {}),
                         ...(flow.slippageBps !== undefined ? { slippageBps: flow.slippageBps } : {}),
                         chainStrategies: {},
-                        currentStrategyChain: (flow.selectedChains ?? ["solana"])[0],
+                        currentStrategyChain: this.selectedChainsForSetup(flow)[0] ?? "solana",
                     };
-                    this.addAgentMessage(this.setupPromptFor("strategy"));
+                    this.addAgentMessage(this.setupPromptForStrategyChain(this.selectedChainsForSetup(flow)[0] ?? "solana"));
                     return;
                 }
                 if (!isAffirmative(text)) {
@@ -712,7 +1043,7 @@ export class AgentBridge {
                 }
                 if (!flow.strategyText) {
                     this.setupFlow = { ...flow, step: "strategy" };
-                    this.addAgentMessage(this.setupPromptFor("strategy"));
+                    this.addAgentMessage(this.setupPromptForStrategyChain(flow.currentStrategyChain ?? this.selectedChainsForSetup(flow)[0] ?? "solana"));
                     return;
                 }
                 await this.callSetupAgent({
@@ -729,7 +1060,7 @@ export class AgentBridge {
             }
             if (flow.step === "subscriptions") {
                 if (isAffirmative(text)) {
-                    const chains = flow.selectedChains ?? ["solana"];
+                    const chains = this.selectedChainsForSetup(flow);
                     if (chains.includes("solana")) {
                         await this.mcp.callTool("create_subscription", {
                             type: "new_token_launch",
@@ -777,18 +1108,16 @@ export class AgentBridge {
             return;
         if (name === "setup_agent") {
             const structured = asRecord(parsed.structured) ?? parsed;
-            const wallets = collectWallets(structured);
-            if (wallets.length > 0) {
-                this.setters.setStatus((prev) => ({
-                    ...prev,
-                    wallets: mergeWallets(prev.wallets, wallets),
-                }));
-            }
             if (structured.action === "create_wallet") {
                 const chain = normalizeChain(structured.chain);
-                const address = typeof structured.address === "string" ? structured.address : undefined;
-                if (chain && address) {
-                    this.upsertWallet({ chain, address });
+                const wallet = chain ? readWallet({ ...structured, chain }) : null;
+                if (wallet) {
+                    this.upsertWallet(wallet);
+                }
+            }
+            else if (structured.action === "get_status" || structured.action === "status") {
+                for (const wallet of collectWallets(structured)) {
+                    this.upsertWallet(wallet);
                 }
             }
             return;
@@ -810,20 +1139,81 @@ export class AgentBridge {
             ?? (data ? firstNumber(data, ["totalValueUsd", "portfolioValueUsd", "portfolio_value_usd", "total_value_usd", "valueUsd"]) : undefined)
             ?? summed.balanceUsd;
         const positions = collectPositions(data ?? snapshot);
+        for (const wallet of wallets) {
+            this.upsertWallet(wallet);
+        }
         this.setters.setStatus((prev) => ({
             ...prev,
             ...(balanceSol !== undefined ? { balanceSol } : {}),
             ...(balanceUsd !== undefined ? { balanceUsd } : {}),
-            ...(wallets.length > 0 ? { wallets: mergeWallets(prev.wallets, wallets) } : {}),
             ...(positions ? { activeTrades: positions } : {}),
         }));
     }
     upsertWallet(wallet) {
+        this.knownWallets = mergeLatestWallets(this.knownWallets, [wallet]);
+        this.persistWallet(wallet);
         this.setters.setStatus((prev) => {
             const wallets = prev.wallets.filter((existing) => existing.chain !== wallet.chain);
             return { ...prev, wallets: [...wallets, wallet] };
         });
     }
+    loadStoredWallets() {
+        const agent = loadAgent();
+        if (!agent || agent.publicId !== this.config.publicId)
+            return [];
+        const wallets = [];
+        if (agent.wallets?.solana)
+            wallets.push({ chain: "solana", address: agent.wallets.solana });
+        if (agent.wallets?.base)
+            wallets.push({ chain: "base", address: agent.wallets.base });
+        return wallets;
+    }
+    syncKnownWalletsToStatus() {
+        if (this.knownWallets.length === 0)
+            return;
+        this.setters.setStatus((prev) => ({
+            ...prev,
+            wallets: mergeLatestWallets(prev.wallets, this.knownWallets),
+        }));
+    }
+    persistActiveAgent(update) {
+        const agent = loadAgent();
+        if (!agent || agent.publicId !== this.config.publicId)
+            return;
+        saveAgent(update(agent));
+    }
+    persistMasterKey(masterKey) {
+        this.persistActiveAgent((agent) => ({
+            ...agent,
+            masterKey,
+        }));
+    }
+    persistWallet(wallet) {
+        this.persistActiveAgent((agent) => {
+            const wallets = { ...(agent.wallets ?? {}) };
+            wallets[wallet.chain] = wallet.address;
+            return {
+                ...agent,
+                wallets,
+            };
+        });
+    }
+    buildRuntimeContext() {
+        if (this.knownWallets.length === 0)
+            return "";
+        return [
+            "Known Balchemy runtime context from local encrypted CLI state:",
+            ...this.knownWallets.map((wallet) => `${walletAddressLabel(wallet.chain)}: ${wallet.address}`),
+            "Funding rule: fund the Solana trading wallet with SOL. Fund the Base trading wallet with ETH on Base for gas and Base-chain capital as required.",
+            "If the user asks where to fund, answer from these addresses.",
+        ].join("\n");
+    }
+    withRuntimeContext(userMessage) {
+        const context = this.buildRuntimeContext();
+        if (!context)
+            return userMessage;
+        return `${context}\n\nUser message:\n${userMessage}`;
+    }
     async ensureDefaultSubscriptions() {
         if (!this.config.autoSeedSubscriptions) {
             return;