@t2000/cli 0.17.29 → 0.18.0

package/dist/index.js

@@ -1,5 +1,3199 @@
 #!/usr/bin/env node
-import { createProgram } from './program.js';
-const program = createProgram();
+#!/usr/bin/env node
+import "./chunk-MKTCPK75.js";
+
+// src/program.ts
+import { Command } from "commander";
+import { createRequire } from "module";
+
+// src/output.ts
+import pc from "picocolors";
+var jsonMode = false;
+function setJsonMode(enabled) {
+  jsonMode = enabled;
+}
+function isJsonMode() {
+  return jsonMode;
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function printSuccess(message) {
+  if (jsonMode) return;
+  console.log(`  ${pc.green("\u2713")} ${message}`);
+}
+function printError(message) {
+  if (jsonMode) return;
+  console.error(`  ${pc.red("\u2717")} ${message}`);
+}
+function printWarning(message) {
+  if (jsonMode) return;
+  console.log(`  ${pc.yellow("\u26A0")} ${message}`);
+}
+function printInfo(message) {
+  if (jsonMode) return;
+  console.log(`  ${pc.dim(message)}`);
+}
+function printHeader(title) {
+  if (jsonMode) return;
+  console.log();
+  console.log(`  ${pc.bold(title)}`);
+  console.log();
+}
+function printKeyValue(key, value, indent = 2) {
+  if (jsonMode) return;
+  const pad = " ".repeat(indent);
+  console.log(`${pad}${pc.dim(key + ":")}  ${value}`);
+}
+function printBlank() {
+  if (jsonMode) return;
+  console.log();
+}
+function printDivider(width = 53) {
+  if (jsonMode) return;
+  console.log(`  ${pc.dim("\u2500".repeat(width))}`);
+}
+function printLine(text) {
+  if (jsonMode) return;
+  console.log(`  ${text}`);
+}
+function printSeparator() {
+  if (jsonMode) return;
+  console.log(`  ${pc.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}`);
+}
+function explorerUrl(txHash, network = "mainnet") {
+  const base = network === "testnet" ? "https://suiscan.xyz/testnet/tx" : "https://suiscan.xyz/mainnet/tx";
+  const suffix = "";
+  return `${base}/${txHash}${suffix}`;
+}
+function handleError(error) {
+  if (jsonMode) {
+    const data = error instanceof Error && "toJSON" in error ? error.toJSON() : { error: "UNKNOWN", message: String(error) };
+    printJson(data);
+  } else {
+    const msg = error instanceof Error ? error.message : String(error);
+    printError(msg);
+  }
+  process.exit(1);
+}
+
+// src/commands/init.ts
+import pc2 from "picocolors";
+import { T2000, walletExists, SafeguardEnforcer } from "@t2000/sdk";
+
+// src/prompts.ts
+import { password, confirm } from "@inquirer/prompts";
+import { readFile, writeFile, unlink, mkdir } from "fs/promises";
+import { resolve } from "path";
+import { homedir } from "os";
+var SESSION_PATH = resolve(homedir(), ".t2000", ".session");
+var MIN_PIN_LENGTH = 4;
+async function askPin(message = "Enter PIN:") {
+  const value = await password({ message });
+  if (!value || value.length < MIN_PIN_LENGTH) {
+    throw new Error(`PIN must be at least ${MIN_PIN_LENGTH} characters`);
+  }
+  return value;
+}
+async function askPinConfirm() {
+  const pin = await password({ message: `Create PIN (min ${MIN_PIN_LENGTH} chars):` });
+  if (!pin || pin.length < MIN_PIN_LENGTH) {
+    throw new Error(`PIN must be at least ${MIN_PIN_LENGTH} characters`);
+  }
+  const confirm_ = await password({ message: "Confirm PIN:" });
+  if (pin !== confirm_) {
+    throw new Error("PINs do not match");
+  }
+  return pin;
+}
+async function askConfirm(message) {
+  return confirm({ message });
+}
+function getPinFromEnv() {
+  return process.env.T2000_PIN ?? process.env.T2000_PASSPHRASE;
+}
+async function readSession() {
+  try {
+    const content = await readFile(SESSION_PATH, "utf-8");
+    return content.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function saveSession(pin) {
+  await mkdir(resolve(homedir(), ".t2000"), { recursive: true });
+  await writeFile(SESSION_PATH, pin, { mode: 384 });
+}
+async function clearSession() {
+  try {
+    await unlink(SESSION_PATH);
+  } catch {
+  }
+}
+async function resolvePin(opts) {
+  const envPin = getPinFromEnv();
+  if (envPin) return envPin;
+  const sessionPin = await readSession();
+  if (sessionPin) return sessionPin;
+  const pin = opts?.confirm ? await askPinConfirm() : await askPin();
+  await saveSession(pin);
+  return pin;
+}
+
+// src/commands/init.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir as homedir2, platform } from "os";
+import { exec } from "child_process";
+var LLM_KEY_URLS = {
+  anthropic: "https://console.anthropic.com/settings/keys",
+  openai: "https://platform.openai.com/api-keys"
+};
+function openBrowser(url) {
+  const cmd = platform() === "darwin" ? "open" : platform() === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} "${url}"`, () => {
+  });
+}
+var CONFIG_DIR = join(homedir2(), ".t2000");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+function registerInit(program2) {
+  program2.command("init").description("Create a new agent bank account \u2014 guided setup with AI + Telegram + safeguards").option("--key <path>", "Key file path").option("--no-sponsor", "Skip gas sponsorship").action(async (opts) => {
+    try {
+      const { select, input, password: password3, confirm: confirm2 } = await import("@inquirer/prompts");
+      console.log("");
+      console.log(`  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510`);
+      console.log(`  \u2502  ${pc2.bold("Welcome to t2000")}                       \u2502`);
+      console.log(`  \u2502  Your personal AI financial advisor     \u2502`);
+      console.log(`  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518`);
+      console.log("");
+      const hasWallet = await walletExists(opts.key);
+      let address = "";
+      const skipWallet = hasWallet;
+      if (skipWallet) {
+        printSuccess("Existing wallet detected");
+        const pin = await password3({ message: "Enter your PIN:" });
+        if (!pin || pin.length < 4) throw new Error("PIN must be at least 4 characters");
+        const agent = await T2000.create({ pin, keyPath: opts.key });
+        address = agent.address();
+        await saveSession(pin);
+        printSuccess(`Wallet unlocked (${address.slice(0, 6)}...${address.slice(-4)})`);
+      } else {
+        console.log(`  ${pc2.bold("Step 1 of 5")} \u2014 Create wallet`);
+        printBlank();
+        const pin = await password3({ message: `Create PIN (min 4 chars):` });
+        if (!pin || pin.length < 4) throw new Error("PIN must be at least 4 characters");
+        const pinConfirm = await password3({ message: "Confirm PIN:" });
+        if (pin !== pinConfirm) throw new Error("PINs do not match");
+        const { agent, address: addr } = await T2000.init({ pin, keyPath: opts.key, sponsored: true });
+        address = addr;
+        await saveSession(pin);
+        printSuccess("Keypair generated");
+        printSuccess("Sui mainnet");
+        printSuccess("5 accounts: Checking, Savings, Credit, Exchange, Investment");
+        printBlank();
+      }
+      const stepNum = skipWallet ? 1 : 3;
+      console.log(`  ${pc2.bold(`Step ${stepNum} of ${skipWallet ? 3 : 5}`)} \u2014 Connect AI`);
+      printBlank();
+      const llmProvider = await select({
+        message: "Which LLM provider?",
+        choices: [
+          { name: "Claude (Anthropic)", value: "anthropic" },
+          { name: "GPT (OpenAI)", value: "openai" },
+          { name: "Skip (CLI only, no chat)", value: "skip" }
+        ]
+      });
+      if (llmProvider !== "skip") {
+        const providerName = llmProvider === "anthropic" ? "Anthropic" : "OpenAI";
+        const keyUrl = LLM_KEY_URLS[llmProvider];
+        printBlank();
+        printInfo(`Opening ${providerName} API keys page in your browser...`);
+        openBrowser(keyUrl);
+        printLine(`  ${pc2.dim(keyUrl)}`);
+        printBlank();
+        const apiKey = await password3({
+          message: `Paste your ${providerName} API key:`
+        });
+        if (!apiKey) throw new Error("API key is required");
+        const config = loadConfig();
+        config.llm = { provider: llmProvider, apiKey };
+        saveConfig(config);
+        const modelName = llmProvider === "anthropic" ? "claude-sonnet-4-20250514" : "gpt-4o";
+        printSuccess(`${providerName} connected \u2014 model: ${modelName}`);
+      } else {
+        printSuccess("Skipped \u2014 use CLI commands directly");
+      }
+      printBlank();
+      const telegramStepNum = skipWallet ? 2 : 4;
+      console.log(`  ${pc2.bold(`Step ${telegramStepNum} of ${skipWallet ? 3 : 5}`)} \u2014 Connect Telegram ${pc2.dim("(optional)")}`);
+      printBlank();
+      const wantsTelegram = await confirm2({
+        message: "Want to chat with your agent on Telegram?",
+        default: true
+      });
+      if (wantsTelegram) {
+        printBlank();
+        printInfo("Opening BotFather in Telegram...");
+        openBrowser("https://t.me/BotFather");
+        printBlank();
+        printLine(`1. Send ${pc2.cyan("/newbot")} to BotFather`);
+        printLine(`2. Pick a name (e.g. "My t2000 Agent")`);
+        printLine(`3. Copy the bot token`);
+        printBlank();
+        const botToken = await input({ message: "Paste the bot token:" });
+        if (!botToken) throw new Error("Bot token is required");
+        printBlank();
+        printInfo("Opening @userinfobot to get your Telegram user ID...");
+        openBrowser("https://t.me/userinfobot");
+        printBlank();
+        printLine(`Send any message to ${pc2.cyan("@userinfobot")} \u2014 it will reply with your ID.`);
+        printBlank();
+        const userId = await input({ message: "Paste your Telegram user ID:" });
+        const config = loadConfig();
+        config.channels = {
+          ...config.channels ?? {},
+          telegram: {
+            enabled: true,
+            botToken,
+            allowedUsers: userId ? [userId] : []
+          },
+          webchat: { enabled: true, port: 2e3 }
+        };
+        saveConfig(config);
+        printSuccess("Telegram connected");
+      } else {
+        printSuccess("Skipped \u2014 you can add Telegram later");
+      }
+      printBlank();
+      const safeguardStepNum = skipWallet ? 3 : 5;
+      console.log(`  ${pc2.bold(`Step ${safeguardStepNum} of ${skipWallet ? 3 : 5}`)} \u2014 Set safeguards`);
+      printBlank();
+      const maxPerTx = await input({
+        message: "Max per transaction ($):",
+        default: "500"
+      });
+      const maxDaily = await input({
+        message: "Max daily sends ($):",
+        default: "1000"
+      });
+      const enforcer = new SafeguardEnforcer(CONFIG_DIR);
+      enforcer.load();
+      enforcer.set("maxPerTx", Number(maxPerTx));
+      enforcer.set("maxDailySend", Number(maxDaily));
+      printSuccess("Safeguards configured");
+      printBlank();
+      console.log(`  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510`);
+      console.log(`  \u2502  ${pc2.green("\u2713 You're all set")}                        \u2502`);
+      console.log(`  \u2502                                         \u2502`);
+      if (llmProvider !== "skip") {
+        console.log(`  \u2502  Start your agent:                      \u2502`);
+        console.log(`  \u2502    ${pc2.cyan("t2000 gateway")}                        \u2502`);
+        console.log(`  \u2502                                         \u2502`);
+      }
+      console.log(`  \u2502  Or use the CLI directly:               \u2502`);
+      console.log(`  \u2502    ${pc2.cyan("t2000 balance")}                        \u2502`);
+      console.log(`  \u2502    ${pc2.cyan("t2000 invest buy 100 SUI")}             \u2502`);
+      console.log(`  \u2502                                         \u2502`);
+      console.log(`  \u2502  Deposit USDC to get started:           \u2502`);
+      console.log(`  \u2502    ${pc2.yellow(address)}  \u2502`);
+      console.log(`  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518`);
+      console.log("");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/send.ts
+import { T2000 as T20002 } from "@t2000/sdk";
+import { truncateAddress, formatUsd } from "@t2000/sdk";
+var KNOWN_ASSETS = /* @__PURE__ */ new Set(["USDC", "USDT", "USDE", "USDSUI", "SUI"]);
+function parseSendArgs(args) {
+  const filtered = args.filter((a) => a.toLowerCase() !== "to");
+  if (filtered.length >= 3 && KNOWN_ASSETS.has(filtered[1].toUpperCase())) {
+    return { amount: parseFloat(filtered[0]), asset: filtered[1].toUpperCase(), recipient: filtered[2] };
+  }
+  if (filtered.length >= 2) {
+    return { amount: parseFloat(filtered[0]), asset: "USDC", recipient: filtered[filtered.length - 1] };
+  }
+  throw new Error("Usage: t2000 send <amount> [asset] [to] <address_or_contact>");
+}
+function registerSend(program2) {
+  program2.command("send").argument("<amount>", "Amount to send").argument("[args...]", 'Asset, "to" keyword, and recipient address or contact name').description("Send USDC (or other asset) to an address or contact name").option("--key <path>", "Key file path").action(async (amount, args, opts) => {
+    try {
+      const { amount: parsedAmount, asset, recipient } = parseSendArgs([amount, ...args]);
+      const pin = await resolvePin();
+      const agent = await T20002.create({ pin, keyPath: opts.key });
+      const result = await agent.send({
+        to: recipient,
+        amount: parsedAmount,
+        asset
+      });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      const displayTo = result.contactName ? `${result.contactName} (${truncateAddress(result.to)})` : truncateAddress(result.to);
+      printSuccess(`Sent ${formatUsd(result.amount)} ${asset.toUpperCase()} \u2192 ${displayTo}`);
+      printKeyValue("Gas", `${result.gasCost.toFixed(4)} ${result.gasCostUnit} (${result.gasMethod})`);
+      printKeyValue("Balance", formatUsd(result.balance.available) + " USDC");
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/balance.ts
+import pc3 from "picocolors";
+import { T2000 as T20003, formatUsd as formatUsd2 } from "@t2000/sdk";
+async function fetchLimits(agent) {
+  const [maxWithdraw, maxBorrow, hf] = await Promise.all([
+    agent.maxWithdraw(),
+    agent.maxBorrow(),
+    agent.healthFactor()
+  ]);
+  return {
+    maxWithdraw: maxWithdraw.maxAmount.toFixed(2),
+    maxBorrow: maxBorrow.maxAmount.toFixed(2),
+    healthFactor: hf.borrowed >= 0.01 ? hf.healthFactor : null
+  };
+}
+function registerBalance(program2) {
+  program2.command("balance").description("Show wallet balance").option("--key <path>", "Key file path").option("--show-limits", "Include maxWithdraw, maxBorrow, and health factor").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T20003.create({ pin, keyPath: opts.key });
+      const bal = await agent.balance();
+      const limits = opts.showLimits ? await fetchLimits(agent) : void 0;
+      if (isJsonMode()) {
+        const output = limits ? { ...bal, limits } : bal;
+        printJson(output);
+        return;
+      }
+      printBlank();
+      const stables = bal.stables ?? {};
+      const stableEntries = Object.entries(stables).filter(([, v]) => v >= 0.01);
+      if (stableEntries.length <= 1) {
+        printKeyValue("Available", `${formatUsd2(bal.available)}  ${pc3.dim("(checking \u2014 spendable)")}`);
+      } else {
+        printKeyValue("Available", `${formatUsd2(bal.available)}  ${pc3.dim("(total stablecoins)")}`);
+        for (const [symbol, amount] of stableEntries) {
+          printLine(`    ${pc3.dim(symbol)}  ${formatUsd2(amount)}`);
+        }
+      }
+      if (bal.savings > 0.01) {
+        const positions = await agent.positions();
+        const saves = positions.positions.filter((p) => p.type === "save");
+        const borrows = positions.positions.filter((p) => p.type === "borrow");
+        const weightedApy = saves.length > 0 ? saves.reduce((sum, p) => sum + p.amount * p.apy, 0) / saves.reduce((sum, p) => sum + p.amount, 0) : 0;
+        const dailyEarning = bal.savings * (weightedApy / 100) / 365;
+        printKeyValue("Savings", `${formatUsd2(bal.savings)}  ${pc3.dim(`(earning ${weightedApy.toFixed(2)}% APY)`)}`);
+        if (bal.debt > 0.01) {
+          const borrowApy = borrows.length > 0 ? borrows.reduce((sum, p) => sum + p.amount * p.apy, 0) / borrows.reduce((sum, p) => sum + p.amount, 0) : 0;
+          printKeyValue("Credit", `${pc3.red(`-${formatUsd2(bal.debt)}`)}  ${pc3.dim(`(${borrowApy.toFixed(2)}% APY)`)}`);
+        }
+        if (bal.investment > 0.01) {
+          const pnlColor = bal.investmentPnL >= 0 ? pc3.green : pc3.red;
+          const pnlSign = bal.investmentPnL >= 0 ? "+" : "";
+          const pnlPct = bal.investment > 0 ? bal.investmentPnL / (bal.investment - bal.investmentPnL) * 100 : 0;
+          let earningInfo = "";
+          try {
+            const portfolio = await agent.getPortfolio();
+            const earningPositions = portfolio.positions.filter((p) => p.earning && p.earningApy);
+            if (earningPositions.length > 0) {
+              const avgApy = earningPositions.reduce((s, p) => s + (p.earningApy ?? 0) * p.currentValue, 0) / earningPositions.reduce((s, p) => s + p.currentValue, 0);
+              earningInfo = `, earning ${avgApy.toFixed(1)}% APY`;
+            }
+          } catch {
+          }
+          printKeyValue("Investment", `${formatUsd2(bal.investment)}  ${pnlColor(`(${pnlSign}${pnlPct.toFixed(1)}%${earningInfo})`)}`);
+        } else {
+          printKeyValue("Investment", pc3.dim("\u2014"));
+        }
+        printSeparator();
+        printKeyValue("Total", `${formatUsd2(bal.total)}`);
+        if (dailyEarning >= 5e-3) {
+          printLine(`  ${pc3.dim(`Earning ~${formatUsd2(dailyEarning)}/day`)}`);
+        }
+      } else {
+        if (bal.debt > 0.01) {
+          printKeyValue("Credit", `${pc3.red(`-${formatUsd2(bal.debt)}`)}`);
+        }
+        printKeyValue("Savings", `${formatUsd2(bal.savings)}`);
+        if (bal.investment > 0.01) {
+          const pnlColor = bal.investmentPnL >= 0 ? pc3.green : pc3.red;
+          const pnlSign = bal.investmentPnL >= 0 ? "+" : "";
+          const pnlPct = bal.investment > 0 ? bal.investmentPnL / (bal.investment - bal.investmentPnL) * 100 : 0;
+          let earningInfo = "";
+          try {
+            const portfolio = await agent.getPortfolio();
+            const earningPositions = portfolio.positions.filter((p) => p.earning && p.earningApy);
+            if (earningPositions.length > 0) {
+              const avgApy = earningPositions.reduce((s, p) => s + (p.earningApy ?? 0) * p.currentValue, 0) / earningPositions.reduce((s, p) => s + p.currentValue, 0);
+              earningInfo = `, earning ${avgApy.toFixed(1)}% APY`;
+            }
+          } catch {
+          }
+          printKeyValue("Investment", `${formatUsd2(bal.investment)}  ${pnlColor(`(${pnlSign}${pnlPct.toFixed(1)}%${earningInfo})`)}`);
+        } else {
+          printKeyValue("Investment", pc3.dim("\u2014"));
+        }
+        printSeparator();
+        printKeyValue("Total", `${formatUsd2(bal.total)}`);
+      }
+      if (limits) {
+        printBlank();
+        printHeader("Limits");
+        printKeyValue("Max withdraw", `${formatUsd2(Number(limits.maxWithdraw))} USDC`, 4);
+        printKeyValue("Max borrow", `${formatUsd2(Number(limits.maxBorrow))} USDC`, 4);
+        const hfDisplay = limits.healthFactor !== null ? limits.healthFactor.toFixed(2) : `${pc3.green("\u221E")}  ${pc3.dim("(no active loan)")}`;
+        printKeyValue("Health factor", hfDisplay, 4);
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/address.ts
+import { T2000 as T20004 } from "@t2000/sdk";
+function registerAddress(program2) {
+  program2.command("address").description("Show wallet address").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T20004.create({ pin, keyPath: opts.key });
+      if (isJsonMode()) {
+        printJson({ address: agent.address() });
+        return;
+      }
+      printBlank();
+      printKeyValue("Address", agent.address());
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/deposit.ts
+import { T2000 as T20005 } from "@t2000/sdk";
+function registerDeposit(program2) {
+  program2.command("deposit").description("Show funding instructions").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T20005.create({ pin, keyPath: opts.key });
+      const info = await agent.deposit();
+      if (isJsonMode()) {
+        printJson(info);
+        return;
+      }
+      printHeader("Fund your wallet");
+      console.log(info.instructions);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/history.ts
+import { T2000 as T20006, truncateAddress as truncateAddress2 } from "@t2000/sdk";
+function registerHistory(program2) {
+  program2.command("history").description("Show transaction history").option("--limit <n>", "Number of transactions", "20").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T20006.create({ pin, keyPath: opts.key });
+      const txns = await agent.history({ limit: parseInt(opts.limit, 10) });
+      if (isJsonMode()) {
+        printJson(txns);
+        return;
+      }
+      printHeader("Transaction History");
+      if (txns.length === 0) {
+        printInfo("No transactions yet.");
+      } else {
+        for (const tx of txns) {
+          const time = tx.timestamp ? new Date(tx.timestamp).toLocaleString() : "unknown";
+          const gas = tx.gasMethod ? ` (${tx.gasMethod})` : "";
+          printLine(`${truncateAddress2(tx.digest)}  ${tx.action}${gas}  ${time}`);
+        }
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/exportKey.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { homedir as homedir3 } from "os";
+import { T2000 as T20007 } from "@t2000/sdk";
+var LOCKFILE = resolve2(homedir3(), ".t2000", ".pin-lock");
+var MAX_ATTEMPTS = 5;
+var LOCKOUT_MS = 5 * 60 * 1e3;
+async function getLockState() {
+  try {
+    const data = JSON.parse(await readFile2(LOCKFILE, "utf-8"));
+    return data;
+  } catch {
+    return { attempts: 0, lockedUntil: 0 };
+  }
+}
+async function setLockState(state) {
+  await mkdir2(resolve2(homedir3(), ".t2000"), { recursive: true });
+  await writeFile2(LOCKFILE, JSON.stringify(state), { mode: 384 });
+}
+function registerExport(program2) {
+  program2.command("export").description("Export private key (raw Ed25519 hex)").option("--key <path>", "Key file path").option("--yes", "Skip confirmation").action(async (opts) => {
+    try {
+      const lock = await getLockState();
+      if (lock.lockedUntil > Date.now()) {
+        const remainSec = Math.ceil((lock.lockedUntil - Date.now()) / 1e3);
+        printError(`Too many failed PIN attempts. Try again in ${remainSec}s.`);
+        return;
+      }
+      if (!opts.yes && !isJsonMode()) {
+        const proceed = await askConfirm(
+          "WARNING: This will display your raw private key. Anyone with this key controls your wallet. Continue?"
+        );
+        if (!proceed) return;
+      }
+      const pin = await resolvePin();
+      let agent;
+      try {
+        agent = await T20007.create({ pin, keyPath: opts.key });
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : "";
+        if (msg.includes("Invalid PIN")) {
+          const newAttempts = lock.attempts + 1;
+          if (newAttempts >= MAX_ATTEMPTS) {
+            await setLockState({ attempts: newAttempts, lockedUntil: Date.now() + LOCKOUT_MS });
+            printError(`Invalid PIN. Account locked for 5 minutes (${newAttempts} failed attempts).`);
+          } else {
+            await setLockState({ attempts: newAttempts, lockedUntil: 0 });
+            printError(`Invalid PIN. ${MAX_ATTEMPTS - newAttempts} attempts remaining.`);
+          }
+          return;
+        }
+        throw error;
+      }
+      await setLockState({ attempts: 0, lockedUntil: 0 });
+      const hex = agent.exportKey();
+      if (isJsonMode()) {
+        printJson({ privateKey: hex, format: "ed25519_hex" });
+        return;
+      }
+      printBlank();
+      printSuccess("Private key (Ed25519, hex):");
+      console.log(`  ${hex}`);
+      printBlank();
+      printInfo("Not a BIP39 mnemonic. Store securely and never share.");
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/importKey.ts
+import { keypairFromPrivateKey, saveKey } from "@t2000/sdk";
+import { password as password2 } from "@inquirer/prompts";
+function registerImport(program2) {
+  program2.command("import").description("Import a wallet from private key").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      let privateKey;
+      if (process.env.T2000_PRIVATE_KEY) {
+        privateKey = process.env.T2000_PRIVATE_KEY;
+      } else {
+        privateKey = await password2({ message: "Enter private key (hex):" });
+      }
+      if (!privateKey) throw new Error("Private key is required");
+      const pin = await resolvePin({ confirm: true });
+      const keypair = keypairFromPrivateKey(privateKey);
+      const address = keypair.getPublicKey().toSuiAddress();
+      await saveKey(keypair, pin, opts.key);
+      if (isJsonMode()) {
+        printJson({ address, imported: true });
+        return;
+      }
+      printBlank();
+      printSuccess("Wallet imported (encrypted)");
+      printKeyValue("Address", address);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/save.ts
+import pc4 from "picocolors";
+import { T2000 as T20009, formatUsd as formatUsd3 } from "@t2000/sdk";
+function registerSave(program2) {
+  const action = async (amountStr, opts) => {
+    try {
+      const amount = amountStr === "all" ? "all" : parseFloat(amountStr);
+      if (amount !== "all" && (isNaN(amount) || amount <= 0)) {
+        throw new Error('Amount must be a positive number or "all"');
+      }
+      const pin = await resolvePin();
+      const agent = await T20009.create({ pin, keyPath: opts.key });
+      let gasManagerUsdc = 0;
+      agent.on("gasAutoTopUp", (data) => {
+        gasManagerUsdc = data.usdcSpent;
+      });
+      const result = await agent.save({ amount, protocol: opts.protocol });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (gasManagerUsdc > 0) {
+        printSuccess(`Gas manager: ${pc4.yellow(formatUsd3(gasManagerUsdc))} USDC \u2192 SUI`);
+      }
+      const protocolName = opts.protocol ?? "best rate";
+      printSuccess(`Saved ${pc4.yellow(formatUsd3(result.amount))} USDC to ${protocolName}`);
+      if (result.fee > 0) {
+        const feeRate = (result.fee / result.amount * 100).toFixed(1);
+        printSuccess(`Protocol fee: ${pc4.dim(`${formatUsd3(result.fee)} USDC (${feeRate}%)`)}`);
+      }
+      printSuccess(`Current APY: ${pc4.green(`${result.apy.toFixed(2)}%`)}`);
+      printSuccess(`Savings balance: ${pc4.yellow(formatUsd3(result.savingsBalance))} USDC`);
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  };
+  program2.command("save").description("Deposit USDC into savings").argument("<amount>", 'Amount to save (or "all")').option("--key <path>", "Key file path").option("--protocol <name>", "Protocol to use (e.g. navi, suilend)").action(action);
+  program2.command("supply").description("Deposit USDC into savings (alias for save)").argument("<amount>", 'Amount to save (or "all")').option("--key <path>", "Key file path").option("--protocol <name>", "Protocol to use (e.g. navi, suilend)").action(action);
+}
+
+// src/commands/withdraw.ts
+import { T2000 as T200010, formatUsd as formatUsd4 } from "@t2000/sdk";
+function registerWithdraw(program2) {
+  program2.command("withdraw").description("Withdraw USDC from savings").argument("<amount>", 'Amount to withdraw (or "all")').option("--key <path>", "Key file path").option("--protocol <name>", "Protocol to use (e.g. navi, suilend)").action(async (amountStr, opts) => {
+    try {
+      const amount = amountStr === "all" ? "all" : parseFloat(amountStr);
+      if (amount !== "all" && (isNaN(amount) || amount <= 0)) {
+        throw new Error('Amount must be a positive number or "all"');
+      }
+      const pin = await resolvePin();
+      const agent = await T200010.create({ pin, keyPath: opts.key });
+      const result = await agent.withdraw({ amount, protocol: opts.protocol });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printSuccess(`Withdrew ${formatUsd4(result.amount)} USDC`);
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/borrow.ts
+import { T2000 as T200011, formatUsd as formatUsd5 } from "@t2000/sdk";
+function registerBorrow(program2) {
+  program2.command("borrow").description("Borrow USDC against savings collateral").argument("<amount>", "Amount to borrow").option("--key <path>", "Key file path").option("--protocol <name>", "Protocol to use (e.g. navi)").action(async (amountStr, opts) => {
+    try {
+      const amount = parseFloat(amountStr);
+      if (isNaN(amount) || amount <= 0) {
+        throw new Error("Amount must be a positive number");
+      }
+      const pin = await resolvePin();
+      const agent = await T200011.create({ pin, keyPath: opts.key });
+      const maxResult = await agent.maxBorrow();
+      if (amount > maxResult.maxAmount) {
+        printWarning(`Max safe borrow: ${formatUsd5(maxResult.maxAmount)} (HF ${maxResult.currentHF.toFixed(2)} \u2192 min 1.5)`);
+        return;
+      }
+      const result = await agent.borrow({ amount, protocol: opts.protocol });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printSuccess(`Borrowed ${formatUsd5(amount)} USDC`);
+      printKeyValue("Health Factor", result.healthFactor.toFixed(2));
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/repay.ts
+import { T2000 as T200012, formatUsd as formatUsd6 } from "@t2000/sdk";
+function registerRepay(program2) {
+  program2.command("repay").description("Repay borrowed USDC").argument("<amount>", 'Amount to repay (or "all")').option("--key <path>", "Key file path").option("--protocol <name>", "Protocol to use (e.g. navi)").action(async (amountStr, opts) => {
+    try {
+      const amount = amountStr === "all" ? "all" : parseFloat(amountStr);
+      if (amount !== "all" && (isNaN(amount) || amount <= 0)) {
+        throw new Error('Amount must be a positive number or "all"');
+      }
+      const pin = await resolvePin();
+      const agent = await T200012.create({ pin, keyPath: opts.key });
+      const result = await agent.repay({ amount, protocol: opts.protocol });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printSuccess(`Repaid ${formatUsd6(result.amount)} USDC`);
+      printKeyValue("Remaining Debt", formatUsd6(result.remainingDebt));
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/health.ts
+import { T2000 as T200013, formatUsd as formatUsd7 } from "@t2000/sdk";
+function registerHealth(program2) {
+  program2.command("health").description("Check savings health factor").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200013.create({ pin, keyPath: opts.key });
+      const hf = await agent.healthFactor();
+      if (isJsonMode()) {
+        printJson(hf);
+        return;
+      }
+      printBlank();
+      const noActiveLoan = hf.borrowed < 0.01;
+      const hfStr = hf.healthFactor === Infinity || noActiveLoan ? "\u221E" : hf.healthFactor.toFixed(2);
+      if (hf.healthFactor >= 2) {
+        printSuccess(`Health Factor: ${hfStr} (healthy)`);
+      } else if (hf.healthFactor >= 1.5) {
+        printWarning(`Health Factor: ${hfStr} (moderate)`);
+      } else if (hf.healthFactor >= 1.2) {
+        printWarning(`Health Factor: ${hfStr} (low)`);
+      } else {
+        printError(`Health Factor: ${hfStr} (CRITICAL)`);
+      }
+      printBlank();
+      printKeyValue("Supplied", `${formatUsd7(hf.supplied)} USDC`);
+      printKeyValue("Borrowed", `${formatUsd7(hf.borrowed)} USDC`);
+      printKeyValue("Max Borrow", `${formatUsd7(hf.maxBorrow)} USDC`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/rates.ts
+import pc5 from "picocolors";
+import { T2000 as T200014, SUPPORTED_ASSETS, INVESTMENT_ASSETS, STABLE_ASSETS } from "@t2000/sdk";
+var INVEST_ASSETS = Object.keys(INVESTMENT_ASSETS);
+function registerRates(program2) {
+  program2.command("rates").description("Show current APY rates across protocols and stablecoins").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200014.create({ pin, keyPath: opts.key });
+      const allRates = await agent.allRatesAcrossAssets();
+      if (isJsonMode()) {
+        printJson(allRates);
+        return;
+      }
+      printBlank();
+      if (allRates.length > 0) {
+        const best = allRates.reduce((a, b) => b.rates.saveApy > a.rates.saveApy ? b : a);
+        const bestDisplay = SUPPORTED_ASSETS[best.asset]?.displayName ?? best.asset;
+        printLine(pc5.bold(pc5.green(`Best yield: ${best.rates.saveApy.toFixed(2)}% APY`)) + pc5.dim(` (${bestDisplay} on ${best.protocol})`));
+        printBlank();
+      }
+      for (const asset of STABLE_ASSETS) {
+        const assetRates = allRates.filter((r) => r.asset === asset);
+        if (assetRates.length === 0) continue;
+        const display = SUPPORTED_ASSETS[asset]?.displayName ?? asset;
+        printLine(pc5.bold(display));
+        printDivider();
+        for (const entry of assetRates) {
+          printKeyValue(entry.protocol, `Save ${entry.rates.saveApy.toFixed(2)}%  Borrow ${entry.rates.borrowApy.toFixed(2)}%`);
+        }
+        printBlank();
+      }
+      const investRates = allRates.filter((r) => INVEST_ASSETS.includes(r.asset));
+      if (investRates.length > 0) {
+        printLine(pc5.bold("Investment Assets"));
+        printDivider();
+        for (const asset of INVEST_ASSETS) {
+          const assetRates = investRates.filter((r) => r.asset === asset);
+          if (assetRates.length === 0) continue;
+          const display = SUPPORTED_ASSETS[asset]?.displayName ?? asset;
+          for (const entry of assetRates) {
+            printKeyValue(`${display} (${entry.protocol})`, `Lend ${entry.rates.saveApy.toFixed(2)}%`);
+          }
+        }
+        printBlank();
+      }
+      if (allRates.length === 0) {
+        printInfo("No protocol rates available");
+        printBlank();
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/positions.ts
+import pc6 from "picocolors";
+import { T2000 as T200015, formatUsd as formatUsd8 } from "@t2000/sdk";
+function registerPositions(program2) {
+  program2.command("positions").description("Show savings & borrow positions across all protocols and assets").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200015.create({ pin, keyPath: opts.key });
+      const result = await agent.positions();
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      let hasRewards = false;
+      const rewardsByKey = /* @__PURE__ */ new Map();
+      try {
+        const pending = await agent.getPendingRewards();
+        for (const r of pending) {
+          rewardsByKey.set(`${r.protocol}:${r.asset}`, true);
+          hasRewards = true;
+        }
+      } catch {
+      }
+      printBlank();
+      if (result.positions.length === 0) {
+        printInfo("No positions. Use `t2000 save <amount>` to start earning.");
+      } else {
+        const saves = result.positions.filter((p) => p.type === "save");
+        const borrows = result.positions.filter((p) => p.type === "borrow");
+        if (saves.length > 0) {
+          printLine(pc6.bold("Savings"));
+          printDivider();
+          for (const pos of saves) {
+            const earning = rewardsByKey.has(`${pos.protocol}:${pos.asset}`) ? `  ${pc6.yellow("+rewards")}` : "";
+            printKeyValue(pos.protocol, `${formatUsd8(pos.amount)} ${pos.asset} @ ${pos.apy.toFixed(2)}% APY${earning}`);
+          }
+          const totalSaved = saves.reduce((s, p) => s + p.amount, 0);
+          if (saves.length > 1) {
+            printKeyValue("Total", formatUsd8(totalSaved));
+          }
+          if (hasRewards) {
+            printLine(`  ${pc6.dim("Run claim-rewards to collect and convert to USDC")}`);
+          }
+          printBlank();
+        }
+        if (borrows.length > 0) {
+          printLine(pc6.bold("Borrows"));
+          printDivider();
+          for (const pos of borrows) {
+            printKeyValue(pos.protocol, `${formatUsd8(pos.amount)} ${pos.asset} @ ${pos.apy.toFixed(2)}% APY`);
+          }
+          const totalBorrowed = borrows.reduce((s, p) => s + p.amount, 0);
+          if (borrows.length > 1) {
+            printKeyValue("Total", formatUsd8(totalBorrowed));
+          }
+          printBlank();
+        }
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/earnings.ts
+import pc7 from "picocolors";
+import { T2000 as T200016, formatUsd as formatUsd9 } from "@t2000/sdk";
+function registerEarnings(program2) {
+  program2.command("earnings").description("Show yield earned to date").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200016.create({ pin, keyPath: opts.key });
+      const result = await agent.earnings();
+      const pos = await agent.positions();
+      const savePositions = pos.positions.filter((p) => p.type === "save");
+      if (isJsonMode()) {
+        printJson({ ...result, positions: savePositions });
+        return;
+      }
+      printBlank();
+      printKeyValue("Total Saved", formatUsd9(result.supplied));
+      if (savePositions.length > 0) {
+        for (const p of savePositions) {
+          printLine(`  ${pc7.dim("\u2022")} ${formatUsd9(p.amount)} ${p.asset} on ${p.protocol} @ ${p.apy.toFixed(2)}% APY`);
+        }
+      }
+      printKeyValue("Blended APY", `${result.currentApy.toFixed(2)}%`);
+      printKeyValue("Daily Yield", `~${formatUsd9(result.dailyEarning)}/day`);
+      printKeyValue("Est. Earned", `~${formatUsd9(result.totalYieldEarned)}`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/fundStatus.ts
+import pc8 from "picocolors";
+import { T2000 as T200017, formatUsd as formatUsd10 } from "@t2000/sdk";
+function registerFundStatus(program2) {
+  program2.command("fund-status").description("Full savings summary").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200017.create({ pin, keyPath: opts.key });
+      const result = await agent.fundStatus();
+      const pos = await agent.positions();
+      const savePositions = pos.positions.filter((p) => p.type === "save");
+      if (isJsonMode()) {
+        printJson({ ...result, positions: savePositions });
+        return;
+      }
+      printBlank();
+      if (result.supplied > 0) {
+        printSuccess("Savings: ACTIVE");
+      } else {
+        printInfo("Savings: INACTIVE \u2014 run `t2000 save <amount>` to start earning");
+      }
+      printBlank();
+      printKeyValue("Total Saved", formatUsd10(result.supplied));
+      if (savePositions.length > 0) {
+        for (const p of savePositions) {
+          printLine(`  ${pc8.dim("\u2022")} ${formatUsd10(p.amount)} ${p.asset} on ${p.protocol} @ ${p.apy.toFixed(2)}% APY`);
+        }
+      }
+      printKeyValue("Blended APY", `${result.apy.toFixed(2)}%`);
+      printKeyValue("Earned today", `~${formatUsd10(result.earnedToday)}`);
+      printKeyValue("Earned all time", `~${formatUsd10(result.earnedAllTime)}`);
+      printKeyValue("Monthly projected", `~${formatUsd10(result.projectedMonthly)}/month`);
+      printBlank();
+      if (result.supplied > 0) {
+        printInfo("Withdraw anytime: t2000 withdraw <amount>");
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/config.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir4 } from "os";
+import { SafeguardEnforcer as SafeguardEnforcer2 } from "@t2000/sdk";
+var CONFIG_DIR2 = join2(homedir4(), ".t2000");
+var CONFIG_PATH2 = join2(CONFIG_DIR2, "config.json");
+var SAFEGUARD_KEYS = /* @__PURE__ */ new Set(["locked", "maxPerTx", "maxDailySend", "dailyUsed", "dailyResetDate", "alertThreshold", "maxLeverage", "maxPositionSize"]);
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current) || typeof current[part] !== "object" || current[part] === null) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function loadConfig2() {
+  try {
+    return JSON.parse(readFileSync2(CONFIG_PATH2, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig2(config) {
+  if (!existsSync2(CONFIG_DIR2)) {
+    mkdirSync2(CONFIG_DIR2, { recursive: true });
+  }
+  writeFileSync2(CONFIG_PATH2, JSON.stringify(config, null, 2) + "\n");
+}
+function formatUsd11(amount) {
+  return `$${amount.toFixed(2)}`;
+}
+function registerConfig(program2) {
+  const configCmd = program2.command("config").description("Show or set configuration");
+  configCmd.command("show").description("Show safeguard settings").action(() => {
+    try {
+      const enforcer = new SafeguardEnforcer2(CONFIG_DIR2);
+      enforcer.load();
+      const config = enforcer.getConfig();
+      if (isJsonMode()) {
+        printJson({
+          locked: config.locked,
+          maxPerTx: config.maxPerTx,
+          maxDailySend: config.maxDailySend,
+          dailyUsed: config.dailyUsed
+        });
+        return;
+      }
+      printHeader("Agent Safeguards");
+      printDivider();
+      printKeyValue("Locked", config.locked ? "Yes" : "No");
+      printKeyValue("Per-transaction", config.maxPerTx > 0 ? formatUsd11(config.maxPerTx) : "Unlimited");
+      printKeyValue("Daily send limit", config.maxDailySend > 0 ? `${formatUsd11(config.maxDailySend)} (${formatUsd11(config.dailyUsed)} used today)` : "Unlimited");
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  configCmd.command("get").argument("[key]", "Config key to get, supports dot notation (e.g. llm.provider)").action((key) => {
+    try {
+      const config = loadConfig2();
+      if (key) {
+        const value = key.includes(".") ? getNestedValue(config, key) : config[key];
+        if (isJsonMode()) {
+          printJson({ [key]: value });
+          return;
+        }
+        printBlank();
+        const display = typeof value === "object" ? JSON.stringify(value) : String(value ?? "(not set)");
+        printKeyValue(key, display);
+      } else {
+        if (isJsonMode()) {
+          printJson(config);
+          return;
+        }
+        printBlank();
+        if (Object.keys(config).length === 0) {
+          printInfo("No configuration set.");
+        } else {
+          for (const [k, v] of Object.entries(config)) {
+            const display = typeof v === "object" ? JSON.stringify(v) : String(v);
+            printKeyValue(k, display);
+          }
+        }
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  configCmd.command("set").argument("<key>", "Config key, supports dot notation (e.g. llm.provider, channels.telegram.botToken)").argument("<value>", "Config value").action((key, value) => {
+    try {
+      const leafKey = key.includes(".") ? key.split(".").pop() : key;
+      if (SAFEGUARD_KEYS.has(leafKey) && !key.includes(".")) {
+        const enforcer = new SafeguardEnforcer2(CONFIG_DIR2);
+        enforcer.load();
+        let parsed2 = value;
+        if (value === "true") parsed2 = true;
+        else if (value === "false") parsed2 = false;
+        else if (!isNaN(Number(value)) && value.trim() !== "") parsed2 = Number(value);
+        enforcer.set(key, parsed2);
+        if (isJsonMode()) {
+          printJson({ [key]: parsed2 });
+          return;
+        }
+        printBlank();
+        printSuccess(`Set ${key} = ${String(parsed2)}`);
+        printBlank();
+        return;
+      }
+      const config = loadConfig2();
+      let parsed = value;
+      if (value === "true") parsed = true;
+      else if (value === "false") parsed = false;
+      else if (!isNaN(Number(value)) && value.trim() !== "") parsed = Number(value);
+      if (value.startsWith("[") || value.startsWith("{")) {
+        try {
+          parsed = JSON.parse(value);
+        } catch {
+        }
+      }
+      if (key.includes(".")) {
+        setNestedValue(config, key, parsed);
+      } else {
+        config[key] = parsed;
+      }
+      saveConfig2(config);
+      if (isJsonMode()) {
+        printJson({ [key]: parsed });
+        return;
+      }
+      printBlank();
+      printSuccess(`Set ${key} = ${String(parsed)}`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/serve.ts
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { randomBytes } from "crypto";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir5 } from "os";
+import { T2000 as T200018 } from "@t2000/sdk";
+import { streamSSE } from "hono/streaming";
+var CONFIG_DIR3 = join3(homedir5(), ".t2000");
+var TOKEN_PATH = join3(CONFIG_DIR3, "config.json");
+function generateToken() {
+  return `t2k_${randomBytes(24).toString("hex")}`;
+}
+function saveToken(token) {
+  if (!existsSync3(CONFIG_DIR3)) {
+    mkdirSync3(CONFIG_DIR3, { recursive: true });
+  }
+  let config = {};
+  try {
+    config = JSON.parse(readFileSync3(TOKEN_PATH, "utf-8"));
+  } catch {
+  }
+  config.authToken = token;
+  writeFileSync3(TOKEN_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+function envelope(data) {
+  return { success: true, data, timestamp: Math.floor(Date.now() / 1e3) };
+}
+function errorResponse(code, message, data, retryable = false) {
+  return {
+    success: false,
+    error: { code, message, data, retryable },
+    timestamp: Math.floor(Date.now() / 1e3)
+  };
+}
+function registerServe(program2) {
+  program2.command("serve").description("Start HTTP API server").option("--port <port>", "Port number", "3001").option("--rate-limit <rps>", "Max requests per second", "10").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200018.create({ pin, keyPath: opts.key });
+      const port = parseInt(opts.port, 10);
+      const rateLimit = parseInt(opts.rateLimit, 10);
+      const token = generateToken();
+      saveToken(token);
+      const app = buildApp(agent, token, rateLimit);
+      serve({ fetch: app.fetch, port });
+      console.log(`  \u2713 API server running on http://localhost:${port}`);
+      console.log(`  \u2713 Auth token: ${token}`);
+      console.log("");
+      console.log("  Endpoints:");
+      console.log("    GET  /v1/balance        POST /v1/send");
+      console.log("    GET  /v1/address         POST /v1/save");
+      console.log("    GET  /v1/history         POST /v1/withdraw");
+      console.log("    GET  /v1/earnings        POST /v1/borrow");
+      console.log("    GET  /v1/rates           POST /v1/repay");
+      console.log("    GET  /v1/health-factor");
+      console.log("    GET  /v1/positions");
+      console.log("    GET  /v1/events          (SSE)");
+      console.log("");
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+function buildApp(agent, authToken, rateLimit) {
+  const app = new Hono();
+  app.use("*", cors());
+  const requestLog = [];
+  app.use("/v1/*", async (c, next) => {
+    const now = Date.now();
+    const windowMs = 1e3;
+    while (requestLog.length > 0 && requestLog[0] < now - windowMs) {
+      requestLog.shift();
+    }
+    if (requestLog.length >= rateLimit) {
+      c.status(429);
+      c.header("Retry-After", "1");
+      return c.json(errorResponse("RATE_LIMITED", "Too many requests", null, true));
+    }
+    requestLog.push(now);
+    await next();
+  });
+  app.use("/v1/*", async (c, next) => {
+    const auth = c.req.header("Authorization");
+    if (!auth || auth !== `Bearer ${authToken}`) {
+      c.status(401);
+      return c.json(errorResponse("UNAUTHORIZED", "Invalid or missing Bearer token"));
+    }
+    await next();
+  });
+  app.get("/v1/address", (c) => {
+    return c.json(envelope({ address: agent.address }));
+  });
+  app.get("/v1/balance", async (c) => {
+    try {
+      const balance = await agent.balance();
+      return c.json(envelope(balance));
+    } catch (err) {
+      return c.json(errorResponse("BALANCE_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/history", async (c) => {
+    try {
+      const limit = parseInt(c.req.query("limit") ?? "20", 10);
+      const history = await agent.history({ limit });
+      return c.json(envelope(history));
+    } catch (err) {
+      return c.json(errorResponse("HISTORY_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/deposit", (c) => {
+    return c.json(envelope({
+      address: agent.address,
+      network: "mainnet",
+      instructions: "Send USDC to this address on Sui mainnet."
+    }));
+  });
+  app.get("/v1/earnings", async (c) => {
+    try {
+      const earnings = await agent.earnings();
+      return c.json(envelope(earnings));
+    } catch (err) {
+      return c.json(errorResponse("EARNINGS_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/rates", async (c) => {
+    try {
+      const rates = await agent.rates();
+      return c.json(envelope(rates));
+    } catch (err) {
+      return c.json(errorResponse("RATES_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/health-factor", async (c) => {
+    try {
+      const hf = await agent.healthFactor();
+      return c.json(envelope(hf));
+    } catch (err) {
+      return c.json(errorResponse("HEALTH_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/max-withdraw", async (c) => {
+    try {
+      const result = await agent.maxWithdraw();
+      return c.json(envelope(result));
+    } catch (err) {
+      return c.json(errorResponse("MAX_WITHDRAW_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/max-borrow", async (c) => {
+    try {
+      const result = await agent.maxBorrow();
+      return c.json(envelope(result));
+    } catch (err) {
+      return c.json(errorResponse("MAX_BORROW_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.get("/v1/positions", async (c) => {
+    try {
+      const positions = await agent.positions();
+      return c.json(envelope(positions));
+    } catch (err) {
+      return c.json(errorResponse("POSITIONS_ERROR", errMsg(err)), 500);
+    }
+  });
+  app.post("/v1/send", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { to, amount, asset } = body;
+      if (!to || !amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: to, amount"));
+      }
+      const result = await agent.send({ to, amount, asset: asset ?? "USDC" });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.post("/v1/save", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { amount } = body;
+      if (!amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: amount"));
+      }
+      const result = await agent.save({ amount });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.post("/v1/supply", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { amount } = body;
+      if (!amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: amount"));
+      }
+      const result = await agent.save({ amount });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.post("/v1/withdraw", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { amount } = body;
+      if (!amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: amount"));
+      }
+      const result = await agent.withdraw({ amount });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.post("/v1/borrow", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { amount } = body;
+      if (!amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: amount"));
+      }
+      const result = await agent.borrow({ amount });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.post("/v1/repay", async (c) => {
+    try {
+      const body = await c.req.json();
+      const { amount } = body;
+      if (!amount) {
+        c.status(400);
+        return c.json(errorResponse("INVALID_PARAMS", "Required: amount"));
+      }
+      const result = await agent.repay({ amount });
+      return c.json(envelope(result));
+    } catch (err) {
+      c.status(getStatusCode(err));
+      return c.json(handleApiError(err));
+    }
+  });
+  app.get("/v1/events", async (c) => {
+    const subscribeParam = c.req.query("subscribe") ?? "yield,balanceChange,healthWarning";
+    const subscriptions = new Set(subscribeParam.split(",").map((s) => s.trim()));
+    return streamSSE(c, async (stream) => {
+      const handlers = [];
+      for (const eventName of subscriptions) {
+        const handler = (data) => {
+          stream.writeSSE({ event: eventName, data: JSON.stringify(data) }).catch(() => {
+          });
+        };
+        agent.on(eventName, handler);
+        handlers.push({
+          event: eventName,
+          off: () => agent.off(eventName, handler)
+        });
+      }
+      const keepAlive = setInterval(() => {
+        stream.writeSSE({ event: "ping", data: "{}" }).catch(() => {
+        });
+      }, 3e4);
+      stream.onAbort(() => {
+        clearInterval(keepAlive);
+        for (const h of handlers) h.off();
+      });
+      await new Promise(() => {
+      });
+    });
+  });
+  return app;
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function handleApiError(err) {
+  const t2kErr = err;
+  return errorResponse(
+    t2kErr.code ?? "UNKNOWN",
+    t2kErr.message ?? errMsg(err),
+    t2kErr.data,
+    isRetryable(t2kErr.code)
+  );
+}
+function getStatusCode(err) {
+  const code = err.code;
+  if (!code) return 500;
+  if (code === "INSUFFICIENT_BALANCE") return 400;
+  if (code === "INVALID_ADDRESS") return 400;
+  if (code === "WITHDRAW_WOULD_LIQUIDATE") return 400;
+  if (code === "NO_COLLATERAL") return 400;
+  return 500;
+}
+function isRetryable(code) {
+  if (!code) return false;
+  return ["RPC_ERROR", "RPC_UNREACHABLE", "SPONSOR_UNAVAILABLE", "AUTO_TOPUP_FAILED"].includes(code);
+}
+
+// src/commands/pay.ts
+import pc9 from "picocolors";
+import { T2000 as T200019 } from "@t2000/sdk";
+import { x402Client } from "@t2000/x402";
+function createX402Wallet(agent) {
+  return {
+    client: agent.suiClient,
+    keypair: agent.signer,
+    address: () => agent.address(),
+    signAndExecute: async (tx) => {
+      const result = await agent.suiClient.signAndExecuteTransaction({
+        signer: agent.signer,
+        transaction: tx
+      });
+      return { digest: result.digest };
+    }
+  };
+}
+function registerPay(program2) {
+  program2.command("pay <url>").description("Pay for an x402-protected API resource").option("--key <path>", "Key file path").option("--method <method>", "HTTP method (GET, POST, PUT)", "GET").option("--data <json>", "Request body for POST/PUT").option("--header <key=value>", "Additional HTTP header (repeatable)", collectHeaders, {}).option("--max-price <amount>", "Max USDC price to auto-approve", "1.00").option("--timeout <seconds>", "Request timeout in seconds", "30").option("--dry-run", "Show what would be paid without paying").action(async (url, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200019.create({ pin, keyPath: opts.key });
+      agent.enforcer.check({ operation: "pay", amount: parseFloat(opts.maxPrice) });
+      const wallet = createX402Wallet(agent);
+      const client = new x402Client(wallet);
+      const startTime = Date.now();
+      if (!isJsonMode()) {
+        printBlank();
+        printInfo(`\u2192 ${opts.method} ${url}`);
+      }
+      const response = await client.fetch(url, {
+        method: opts.method,
+        headers: opts.header,
+        body: opts.data,
+        maxPrice: parseFloat(opts.maxPrice),
+        timeout: parseInt(opts.timeout, 10) * 1e3,
+        dryRun: opts.dryRun,
+        onPayment: (details) => {
+          if (!isJsonMode()) {
+            printInfo(`\u2190 402 Payment Required: $${details.amount} USDC (Sui)`);
+            printSuccess(`Paid $${details.amount} USDC (tx: ${details.txHash.slice(0, 10)}...)`);
+          }
+        }
+      });
+      const elapsed = Date.now() - startTime;
+      if (!isJsonMode()) {
+        printInfo(`\u2190 ${response.status} ${response.statusText || "OK"}  ${pc9.dim(`[${elapsed}ms]`)}`);
+      }
+      const contentType = response.headers.get("content-type") ?? "";
+      const body = contentType.includes("application/json") ? await response.json() : await response.text();
+      if (isJsonMode()) {
+        printJson({
+          status: response.status,
+          url,
+          elapsed,
+          body
+        });
+      } else {
+        printBlank();
+        if (typeof body === "string") {
+          console.log(body);
+        } else {
+          console.log(JSON.stringify(body, null, 2));
+        }
+        printBlank();
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+function collectHeaders(value, previous) {
+  const [key, ...rest] = value.split("=");
+  if (key && rest.length > 0) {
+    previous[key.trim()] = rest.join("=").trim();
+  }
+  return previous;
+}
+
+// src/commands/lock.ts
+import { join as join4 } from "path";
+import { homedir as homedir6 } from "os";
+import { SafeguardEnforcer as SafeguardEnforcer3 } from "@t2000/sdk";
+var CONFIG_DIR4 = join4(homedir6(), ".t2000");
+function registerLock(program2) {
+  program2.command("lock").description("Lock agent \u2014 freeze all operations").action(async () => {
+    try {
+      const enforcer = new SafeguardEnforcer3(CONFIG_DIR4);
+      enforcer.load();
+      enforcer.lock();
+      await clearSession();
+      if (isJsonMode()) {
+        printJson({ locked: true });
+        return;
+      }
+      printBlank();
+      printSuccess("Agent locked. All operations frozen.");
+      printInfo("Run: t2000 unlock  (requires PIN)");
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  program2.command("unlock").description("Unlock agent \u2014 resume operations").action(async () => {
+    try {
+      const pin = await resolvePin();
+      if (!pin) {
+        throw new Error("PIN required to unlock agent");
+      }
+      const { T2000: T200028 } = await import("@t2000/sdk");
+      await T200028.create({ pin });
+      const enforcer = new SafeguardEnforcer3(CONFIG_DIR4);
+      enforcer.load();
+      enforcer.unlock();
+      if (isJsonMode()) {
+        printJson({ locked: false });
+        return;
+      }
+      const config = enforcer.getConfig();
+      printBlank();
+      printSuccess("Agent unlocked. Operations resumed.");
+      if (config.maxPerTx > 0 || config.maxDailySend > 0) {
+        const limits = [];
+        if (config.maxPerTx > 0) limits.push(`maxPerTx=$${config.maxPerTx}`);
+        if (config.maxDailySend > 0) limits.push(`maxDailySend=$${config.maxDailySend}`);
+        printInfo(`Active safeguards: ${limits.join(", ")}`);
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/sentinel.ts
+import { T2000 as T200020, MIST_PER_SUI } from "@t2000/sdk";
+import pc10 from "picocolors";
+function formatSui(mist) {
+  return (Number(mist) / Number(MIST_PER_SUI)).toFixed(2);
+}
+function registerSentinel(program2) {
+  const sentinel = program2.command("sentinel").description("Interact with Sui Sentinel \u2014 attack AI agents, earn bounties");
+  sentinel.command("list").description("List active sentinels with prize pools").action(async () => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200020.create({ pin });
+      const sentinels = await agent.sentinelList();
+      if (isJsonMode()) {
+        printJson(sentinels.map((s) => ({
+          ...s,
+          attackFee: s.attackFee.toString(),
+          prizePool: s.prizePool.toString()
+        })));
+        return;
+      }
+      if (sentinels.length === 0) {
+        printBlank();
+        printInfo("No active sentinels found.");
+        printBlank();
+        return;
+      }
+      printHeader("Active Sentinels");
+      sentinels.forEach((s) => {
+        const pool = `${formatSui(s.prizePool)} SUI`.padEnd(12);
+        const fee = `${formatSui(s.attackFee)} SUI`.padEnd(12);
+        printLine(`  ${s.name}`);
+        printLine(`  ${pc10.dim(`Pool: ${pool}Fee: ${fee}Attacks: ${s.totalAttacks}`)}`);
+        printLine(`  ${pc10.dim(s.objectId)}`);
+        printBlank();
+      });
+      printBlank();
+      printInfo(`${sentinels.length} active sentinel${sentinels.length === 1 ? "" : "s"}`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  sentinel.command("info").description("Show details for a sentinel").argument("<id>", "Sentinel object ID").action(async (id) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200020.create({ pin });
+      const s = await agent.sentinelInfo(id);
+      if (isJsonMode()) {
+        printJson({
+          ...s,
+          attackFee: s.attackFee.toString(),
+          prizePool: s.prizePool.toString()
+        });
+        return;
+      }
+      printHeader(s.name);
+      printKeyValue("Object ID", s.objectId);
+      printKeyValue("Agent ID", s.id);
+      printKeyValue("Model", s.model);
+      printKeyValue("State", s.state);
+      printKeyValue("Attack Fee", `${formatSui(s.attackFee)} SUI`);
+      printKeyValue("Prize Pool", `${formatSui(s.prizePool)} SUI`);
+      printKeyValue("Total Attacks", String(s.totalAttacks));
+      printKeyValue("Breaches", String(s.successfulBreaches));
+      if (s.systemPrompt) {
+        printBlank();
+        printKeyValue("System Prompt", "");
+        printLine(`  ${pc10.dim(s.systemPrompt.slice(0, 500))}`);
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  sentinel.command("attack").description("Attack a sentinel with a prompt (costs SUI)").argument("<id>", "Sentinel object ID").argument("[prompt]", "Attack prompt").option("--fee <sui>", "Override attack fee in SUI").option("--key <path>", "Key file path").action(async (id, prompt, opts) => {
+    try {
+      if (!prompt) {
+        throw new Error('Prompt is required. Usage: t2000 sentinel attack <id> "your prompt"');
+      }
+      const pin = await resolvePin();
+      const agent = await T200020.create({ pin, keyPath: opts.key });
+      const feeMist = opts.fee ? BigInt(Math.round(parseFloat(opts.fee) * Number(MIST_PER_SUI))) : void 0;
+      if (isJsonMode()) {
+        const result2 = await agent.sentinelAttack(id, prompt, feeMist);
+        printJson({
+          ...result2,
+          verdict: {
+            ...result2.verdict
+          }
+        });
+        return;
+      }
+      printBlank();
+      printLine(`  ${pc10.dim("\u23F3")} Requesting attack...`);
+      const result = await agent.sentinelAttack(id, prompt, feeMist);
+      printBlank();
+      if (result.won) {
+        printSuccess(`BREACHED! (score: ${result.verdict.score}/100)`);
+      } else {
+        printError(`DEFENDED (score: ${result.verdict.score}/100)`);
+      }
+      printBlank();
+      printKeyValue("Agent", result.verdict.agentResponse.slice(0, 200));
+      printKeyValue("Jury", result.verdict.juryResponse.slice(0, 200));
+      if (result.verdict.funResponse) {
+        printKeyValue("Fun", result.verdict.funResponse.slice(0, 200));
+      }
+      printBlank();
+      printKeyValue("Fee Paid", `${result.feePaid} SUI`);
+      printKeyValue("Request Tx", explorerUrl(result.requestTx));
+      printKeyValue("Settle Tx", explorerUrl(result.settleTx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/earn.ts
+import { T2000 as T200021, MIST_PER_SUI as MIST_PER_SUI2, listSentinels, formatUsd as formatUsd12 } from "@t2000/sdk";
+import pc11 from "picocolors";
+function mistToSui(mist) {
+  return Number(mist) / Number(MIST_PER_SUI2);
+}
+function bestTarget(sentinels) {
+  const withPool = sentinels.filter((s) => s.prizePool > 0n && s.attackFee > 0n);
+  if (withPool.length === 0) return void 0;
+  return withPool.sort((a, b) => {
+    const ratioA = Number(a.prizePool) / Number(a.attackFee);
+    const ratioB = Number(b.prizePool) / Number(b.attackFee);
+    return ratioB - ratioA;
+  })[0];
+}
+function registerEarn(program2) {
+  program2.command("earn").description("Show all earning opportunities \u2014 savings yield + sentinel bounties").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200021.create({ pin, keyPath: opts.key });
+      const [positionsResult, portfolioResult, ratesResult, sentinels] = await Promise.allSettled([
+        agent.positions(),
+        agent.getPortfolio(),
+        agent.allRates("USDC"),
+        listSentinels()
+      ]);
+      const posData = positionsResult.status === "fulfilled" ? positionsResult.value : null;
+      const portfolio = portfolioResult.status === "fulfilled" ? portfolioResult.value : null;
+      const ratesData = ratesResult.status === "fulfilled" ? ratesResult.value : null;
+      const agents = sentinels.status === "fulfilled" ? sentinels.value : null;
+      const savePositions = posData?.positions.filter((p) => p.type === "save") ?? [];
+      const totalSaved = savePositions.reduce((s, p) => s + p.amount, 0);
+      const earningInvestments = portfolio?.positions.filter((p) => p.earning && p.currentValue > 0) ?? [];
+      const bestSaveApy = ratesData?.length ? Math.max(...ratesData.map((r) => r.rates.saveApy)) : 0;
+      if (isJsonMode()) {
+        const best = agents ? bestTarget(agents) : void 0;
+        const totalPool = agents ? agents.reduce((sum, s) => sum + mistToSui(s.prizePool), 0) : 0;
+        const cheapest = agents ? Math.min(...agents.map((s) => mistToSui(s.attackFee))) : 0;
+        printJson({
+          savings: savePositions.map((p) => ({
+            protocol: p.protocol,
+            asset: p.asset,
+            amount: p.amount,
+            apy: p.apy
+          })),
+          totalSaved,
+          availableRates: ratesData?.map((r) => ({
+            protocol: r.protocol,
+            asset: "USDC",
+            saveApy: r.rates.saveApy
+          })) ?? [],
+          investments: earningInvestments.map((p) => ({
+            asset: p.asset,
+            amount: p.totalAmount,
+            value: p.currentValue,
+            protocol: p.earningProtocol,
+            apy: p.earningApy
+          })),
+          sentinel: agents ? {
+            activeSentinels: agents.length,
+            totalPrizePool: Number(totalPool.toFixed(2)),
+            cheapestFee: Number(cheapest.toFixed(2)),
+            bestTarget: best ? {
+              name: best.name,
+              objectId: best.objectId,
+              prizePool: mistToSui(best.prizePool),
+              attackFee: mistToSui(best.attackFee),
+              ratio: Number((Number(best.prizePool) / Number(best.attackFee)).toFixed(1))
+            } : null
+          } : null
+        });
+        return;
+      }
+      printHeader("Earning Opportunities");
+      printLine(pc11.bold("SAVINGS") + pc11.dim(" \u2014 Passive Yield"));
+      printDivider();
+      if (savePositions.length > 0) {
+        for (const pos of savePositions) {
+          const dailyYield = pos.amount * pos.apy / 100 / 365;
+          printKeyValue(pos.protocol, `${formatUsd12(pos.amount)} ${pos.asset} @ ${pos.apy.toFixed(2)}% APY`);
+          if (dailyYield > 1e-4) {
+            const dailyStr = dailyYield < 0.01 ? `$${dailyYield.toFixed(4)}` : formatUsd12(dailyYield);
+            const monthlyStr = dailyYield * 30 < 0.01 ? `$${(dailyYield * 30).toFixed(4)}` : formatUsd12(dailyYield * 30);
+            printLine(pc11.dim(`    ~${dailyStr}/day \xB7 ~${monthlyStr}/month`));
+          }
+        }
+        if (savePositions.length > 1) {
+          printBlank();
+          printKeyValue("Total Saved", formatUsd12(totalSaved));
+        }
+      } else if (ratesData && ratesData.length > 0) {
+        const sorted = [...ratesData].sort((a, b) => b.rates.saveApy - a.rates.saveApy);
+        for (const r of sorted) {
+          printKeyValue(r.protocol, `USDC @ ${r.rates.saveApy.toFixed(2)}% APY`);
+        }
+        const example = 100;
+        const daily = example * bestSaveApy / 100 / 365;
+        const monthly = daily * 30;
+        printLine(pc11.dim(`    Save $${example} \u2192 ~$${daily.toFixed(2)}/day \xB7 ~$${monthly.toFixed(2)}/month`));
+        printBlank();
+        printInfo("No savings yet \u2014 run `t2000 save <amount>` to start");
+      } else if (posData) {
+        printInfo("No savings yet \u2014 run `t2000 save <amount>` to start");
+      } else {
+        printInfo("Savings data unavailable");
+      }
+      if (earningInvestments.length > 0) {
+        printBlank();
+        printLine(pc11.bold("INVESTMENTS") + pc11.dim(" \u2014 Earning Yield"));
+        printDivider();
+        let totalInvestValue = 0;
+        for (const pos of earningInvestments) {
+          const dailyYield = pos.currentValue * (pos.earningApy ?? 0) / 100 / 365;
+          const apyStr = pos.earningApy ? `${pos.earningApy.toFixed(2)}%` : "\u2014";
+          printKeyValue(
+            `${pos.asset} via ${pos.earningProtocol ?? "unknown"}`,
+            `${formatUsd12(pos.currentValue)} (${pos.totalAmount.toFixed(4)} ${pos.asset}) @ ${apyStr} APY`
+          );
+          if (dailyYield > 1e-4) {
+            const dailyStr = dailyYield < 0.01 ? `$${dailyYield.toFixed(4)}` : formatUsd12(dailyYield);
+            const monthlyStr = dailyYield * 30 < 0.01 ? `$${(dailyYield * 30).toFixed(4)}` : formatUsd12(dailyYield * 30);
+            printLine(pc11.dim(`    ~${dailyStr}/day \xB7 ~${monthlyStr}/month`));
+          }
+          totalInvestValue += pos.currentValue;
+        }
+        if (earningInvestments.length > 1) {
+          printBlank();
+          printKeyValue("Total Earning", formatUsd12(totalInvestValue));
+        }
+      }
+      printBlank();
+      printLine(pc11.bold("SENTINEL BOUNTIES") + pc11.dim(" \u2014 Active Red Teaming"));
+      printDivider();
+      if (agents && agents.length > 0) {
+        const totalPool = agents.reduce((sum, s) => sum + mistToSui(s.prizePool), 0);
+        const cheapest = Math.min(...agents.map((s) => mistToSui(s.attackFee)));
+        const best = bestTarget(agents);
+        printKeyValue("Active", `${agents.length} sentinels`);
+        printKeyValue("Prize Pools", `${totalPool.toFixed(2)} SUI available`);
+        printKeyValue("Cheapest Fee", `${cheapest.toFixed(2)} SUI`);
+        if (best) {
+          const ratio = (Number(best.prizePool) / Number(best.attackFee)).toFixed(1);
+          printKeyValue("Best Target", `${best.name} \u2014 ${mistToSui(best.prizePool).toFixed(2)} SUI pool (${ratio}x ratio)`);
+        }
+      } else if (agents) {
+        printInfo("No active bounties right now");
+      } else {
+        printInfo("Sentinel data unavailable");
+      }
+      printBlank();
+      printLine(pc11.bold("Quick Actions"));
+      printDivider();
+      printLine(`  ${pc11.dim("t2000 save <amount> [asset]")}     Save stablecoins for yield`);
+      printLine(`  ${pc11.dim("t2000 invest earn <asset>")}     Earn yield on investments`);
+      printLine(`  ${pc11.dim("t2000 sentinel list")}            Browse sentinel bounties`);
+      printLine(`  ${pc11.dim("t2000 sentinel attack <id>")}     Attack a sentinel`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/rebalance.ts
+import pc12 from "picocolors";
+import { T2000 as T200022, formatUsd as formatUsd13, SUPPORTED_ASSETS as SUPPORTED_ASSETS2 } from "@t2000/sdk";
+function registerRebalance(program2) {
+  program2.command("rebalance").description("Optimize yield \u2014 move savings to the best rate across protocols and stablecoins").option("--key <path>", "Key file path").option("--dry-run", "Show what would happen without executing").option("--min-diff <pct>", "Minimum APY difference to trigger (default: 0.5)", "0.5").option("--max-break-even <days>", "Max break-even days for cross-asset moves (default: 30)", "30").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200022.create({ pin, keyPath: opts.key });
+      const minYieldDiff = parseFloat(opts.minDiff ?? "0.5");
+      const maxBreakEven = parseInt(opts.maxBreakEven ?? "30", 10);
+      const plan = await agent.rebalance({
+        dryRun: true,
+        minYieldDiff,
+        maxBreakEven
+      });
+      if (isJsonMode()) {
+        if (opts.dryRun) {
+          printJson(plan);
+        } else {
+          const result2 = await agent.rebalance({ dryRun: false, minYieldDiff, maxBreakEven });
+          printJson(result2);
+        }
+        return;
+      }
+      printBlank();
+      if (plan.steps.length === 0) {
+        const diff = plan.newApy - plan.currentApy;
+        if (diff < minYieldDiff) {
+          printInfo(`Already optimized \u2014 ${plan.currentApy.toFixed(2)}% APY on ${plan.fromProtocol}`);
+          printLine(pc12.dim(`  Best available: ${plan.newApy.toFixed(2)}% (${displayAsset(plan.toAsset)} on ${plan.toProtocol})`));
+          printLine(pc12.dim(`  Difference: ${diff.toFixed(2)}% (below ${minYieldDiff}% threshold)`));
+        } else if (plan.breakEvenDays > maxBreakEven && plan.estimatedSwapCost > 0) {
+          printInfo(`Skipped \u2014 break-even of ${plan.breakEvenDays} days exceeds ${maxBreakEven}-day limit`);
+          printLine(pc12.dim(`  ${displayAsset(plan.fromAsset)} on ${plan.fromProtocol} (${plan.currentApy.toFixed(2)}%) \u2192 ${displayAsset(plan.toAsset)} on ${plan.toProtocol} (${plan.newApy.toFixed(2)}%)`));
+        } else {
+          printInfo("Already at the best rate. Nothing to rebalance.");
+        }
+        printBlank();
+        return;
+      }
+      printLine(pc12.bold("Rebalance Plan"));
+      printDivider();
+      printKeyValue("From", `${displayAsset(plan.fromAsset)} on ${plan.fromProtocol} (${plan.currentApy.toFixed(2)}% APY)`);
+      printKeyValue("To", `${displayAsset(plan.toAsset)} on ${plan.toProtocol} (${plan.newApy.toFixed(2)}% APY)`);
+      printKeyValue("Amount", formatUsd13(plan.amount));
+      printBlank();
+      printLine(pc12.bold("Economics"));
+      printDivider();
+      printKeyValue("APY Gain", `+${(plan.newApy - plan.currentApy).toFixed(2)}%`);
+      printKeyValue("Annual Gain", `${formatUsd13(plan.annualGain)}/year`);
+      if (plan.estimatedSwapCost > 0) {
+        printKeyValue("Swap Cost", `~${formatUsd13(plan.estimatedSwapCost)}`);
+        printKeyValue("Break-even", `${plan.breakEvenDays} days`);
+      }
+      printBlank();
+      if (plan.steps.length > 0) {
+        printLine(pc12.bold("Steps"));
+        printDivider();
+        for (let i = 0; i < plan.steps.length; i++) {
+          const step = plan.steps[i];
+          const num = `${i + 1}.`;
+          if (step.action === "withdraw") {
+            printLine(`  ${num} Withdraw ${formatUsd13(step.amount)} ${displayAsset(step.fromAsset ?? "")} from ${step.protocol}`);
+          } else if (step.action === "swap") {
+            printLine(`  ${num} Swap ${displayAsset(step.fromAsset ?? "")} \u2192 ${displayAsset(step.toAsset ?? "")} (~${formatUsd13(step.estimatedOutput ?? 0)})`);
+          } else if (step.action === "deposit") {
+            printLine(`  ${num} Deposit ${formatUsd13(step.amount)} ${displayAsset(step.toAsset ?? "")} into ${step.protocol}`);
+          }
+        }
+        printBlank();
+      }
+      if (opts.dryRun) {
+        printLine(pc12.bold(pc12.yellow("DRY RUN \u2014 Preview only, no transactions executed")));
+        printLine(pc12.dim("  Run `t2000 rebalance` to execute."));
+        printBlank();
+        return;
+      }
+      const result = await agent.rebalance({ dryRun: false, minYieldDiff, maxBreakEven });
+      if (result.executed) {
+        printSuccess(`Rebalanced ${formatUsd13(result.amount)} \u2192 ${result.newApy.toFixed(2)}% APY`);
+        for (const digest of result.txDigests) {
+          printKeyValue("Tx", explorerUrl(digest));
+        }
+        printKeyValue("Gas", `${result.totalGasCost.toFixed(4)} SUI`);
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+function displayAsset(asset) {
+  return SUPPORTED_ASSETS2[asset]?.displayName ?? asset;
+}
+
+// src/commands/exchange.ts
+import { T2000 as T200023, formatUsd as formatUsd14, SUPPORTED_ASSETS as SUPPORTED_ASSETS3 } from "@t2000/sdk";
+function registerExchange(program2) {
+  program2.command("exchange <amount> <from> <to>").description("Exchange between tokens (e.g. USDC \u21CC SUI) via Cetus DEX").option("--key <path>", "Key file path").option("--slippage <pct>", "Max slippage percentage (default: 3)", "3").action(async (amount, from, to, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200023.create({ pin, keyPath: opts.key });
+      const fromAsset = from.toUpperCase();
+      const toAsset = to.toUpperCase();
+      const parsedAmount = parseFloat(amount);
+      if (isNaN(parsedAmount) || parsedAmount <= 0) {
+        throw new Error("Amount must be a positive number");
+      }
+      const result = await agent.exchange({
+        from: fromAsset,
+        to: toAsset,
+        amount: parsedAmount,
+        maxSlippage: parseFloat(opts.slippage ?? "3")
+      });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      const fromDisplay = SUPPORTED_ASSETS3[fromAsset]?.displayName ?? fromAsset;
+      const toDisplay = SUPPORTED_ASSETS3[toAsset]?.displayName ?? toAsset;
+      const toDecimals = toAsset === "SUI" ? 4 : 2;
+      printBlank();
+      const fromStr = ["USDC", "USDT", "USDE"].includes(fromAsset) ? formatUsd14(parsedAmount) : parsedAmount.toFixed(4);
+      printSuccess(`Exchanged ${fromStr} ${fromDisplay} \u2192 ${result.toAmount.toFixed(toDecimals)} ${toDisplay}`);
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printKeyValue("Gas", `${result.gasCost.toFixed(4)} SUI (${result.gasMethod})`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/mcp.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { join as join5, dirname } from "path";
+import { homedir as homedir7 } from "os";
+import { existsSync as existsSync4 } from "fs";
+var MCP_CONFIG = {
+  command: "t2000",
+  args: ["mcp"]
+};
+function getPlatformConfigs() {
+  const home = homedir7();
+  return [
+    {
+      name: "Claude Desktop",
+      path: join5(home, "Library", "Application Support", "Claude", "claude_desktop_config.json")
+    },
+    {
+      name: "Cursor (global)",
+      path: join5(home, ".cursor", "mcp.json")
+    }
+  ];
+}
+async function readJsonFile(path) {
+  try {
+    const content = await readFile3(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+async function writeJsonFile(path, data) {
+  const dir = dirname(path);
+  if (!existsSync4(dir)) {
+    await mkdir3(dir, { recursive: true });
+  }
+  await writeFile3(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function registerMcp(program2) {
+  const mcp = program2.command("mcp").description("MCP server for AI platforms");
+  mcp.command("start", { isDefault: true }).description("Start MCP server (stdio transport)").option("--key <path>", "Key file path").action(async (opts) => {
+    let mod;
+    try {
+      mod = await import("./dist-6ADOH23K.js");
+    } catch {
+      console.error(
+        "MCP server not installed. Run:\n  npm install -g @t2000/mcp"
+      );
+      process.exit(1);
+    }
+    await mod.startMcpServer({ keyPath: opts.key });
+  });
+  mcp.command("install").description("Auto-configure MCP in Claude Desktop and Cursor").action(async () => {
+    try {
+      const platforms = getPlatformConfigs();
+      const results = [];
+      for (const platform3 of platforms) {
+        const config = await readJsonFile(platform3.path);
+        if (config.mcpServers && config.mcpServers["t2000"]) {
+          results.push({ name: platform3.name, status: "exists" });
+          continue;
+        }
+        config.mcpServers = {
+          ...config.mcpServers ?? {},
+          t2000: MCP_CONFIG
+        };
+        await writeJsonFile(platform3.path, config);
+        results.push({ name: platform3.name, status: "added" });
+      }
+      if (isJsonMode()) {
+        printJson({ installed: results });
+        return;
+      }
+      printBlank();
+      for (const r of results) {
+        if (r.status === "exists") {
+          printInfo(`${r.name}  already configured`);
+        } else {
+          printSuccess(`${r.name}  configured`);
+        }
+      }
+      printBlank();
+      printInfo("Restart your AI platform to activate.");
+      printInfo(`Then ask: "what's my t2000 balance?"`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  mcp.command("uninstall").description("Remove t2000 MCP config from Claude Desktop and Cursor").action(async () => {
+    try {
+      const platforms = getPlatformConfigs();
+      const results = [];
+      for (const platform3 of platforms) {
+        if (!existsSync4(platform3.path)) {
+          results.push({ name: platform3.name, removed: false });
+          continue;
+        }
+        const config = await readJsonFile(platform3.path);
+        if (!config.mcpServers || !config.mcpServers["t2000"]) {
+          results.push({ name: platform3.name, removed: false });
+          continue;
+        }
+        delete config.mcpServers["t2000"];
+        await writeJsonFile(platform3.path, config);
+        results.push({ name: platform3.name, removed: true });
+      }
+      if (isJsonMode()) {
+        printJson({ uninstalled: results });
+        return;
+      }
+      printBlank();
+      for (const r of results) {
+        if (r.removed) {
+          printSuccess(`${r.name}  removed`);
+        } else {
+          printInfo(`${r.name}  not configured (skipped)`);
+        }
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/contacts.ts
+import { ContactManager, truncateAddress as truncateAddress3 } from "@t2000/sdk";
+function registerContacts(program2) {
+  const contacts = program2.command("contacts").description("Manage contacts (send by name instead of address)");
+  contacts.command("add <name> <address>").description("Add or update a contact").action((name, address) => {
+    try {
+      const manager = new ContactManager();
+      const result = manager.add(name, address);
+      if (isJsonMode()) {
+        const contact2 = manager.get(name);
+        printJson({ action: result.action, name: contact2.name, address: contact2.address });
+        return;
+      }
+      const contact = manager.get(name);
+      printBlank();
+      printSuccess(`${result.action === "added" ? "Added" : "Updated"} ${contact.name} (${truncateAddress3(contact.address)})`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  contacts.command("remove <name>").description("Remove a contact").action((name) => {
+    try {
+      const manager = new ContactManager();
+      const removed = manager.remove(name);
+      if (isJsonMode()) {
+        printJson({ removed, name });
+        return;
+      }
+      printBlank();
+      if (removed) {
+        printSuccess(`Removed ${name}`);
+      } else {
+        printError(`Contact "${name}" not found`);
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  contacts.command("list", { isDefault: true }).description("List all contacts").action(() => {
+    try {
+      const manager = new ContactManager();
+      const list = manager.list();
+      if (isJsonMode()) {
+        printJson(list);
+        return;
+      }
+      if (list.length === 0) {
+        printBlank();
+        printLine("No contacts yet.");
+        printLine("Add one: t2000 contacts add Tom 0x...");
+        printBlank();
+        return;
+      }
+      printHeader("Contacts");
+      const maxNameLen = Math.max(...list.map((c) => c.name.length));
+      for (const contact of list) {
+        const padded = contact.name.padEnd(maxNameLen + 4);
+        printLine(`${padded}${truncateAddress3(contact.address)}`);
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/invest.ts
+import pc13 from "picocolors";
+import { T2000 as T200024, formatUsd as formatUsd15, formatAssetAmount, INVESTMENT_ASSETS as INVESTMENT_ASSETS2 } from "@t2000/sdk";
+function registerInvest(program2) {
+  const investCmd = program2.command("invest").description("Buy or sell investment assets");
+  investCmd.command("buy <amount> <asset>").description("Invest USD amount in an asset").option("--key <path>", "Key file path").option("--slippage <pct>", "Max slippage percent", "3").action(async (amount, asset, opts) => {
+    try {
+      const parsed = parseFloat(amount);
+      if (isNaN(parsed) || parsed <= 0 || !isFinite(parsed)) {
+        console.error(pc13.red("  \u2717 Amount must be greater than $0"));
+        process.exitCode = 1;
+        return;
+      }
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const result = await agent.investBuy({
+        asset: asset.toUpperCase(),
+        usdAmount: parsed,
+        maxSlippage: parseFloat(opts.slippage) / 100
+      });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      const sym = asset.toUpperCase();
+      printSuccess(`Bought ${formatAssetAmount(result.amount, sym)} ${sym} at ${formatUsd15(result.price)}`);
+      printKeyValue("Invested", formatUsd15(result.usdValue));
+      printKeyValue("Portfolio", `${formatAssetAmount(result.position.totalAmount, sym)} ${sym} (avg ${formatUsd15(result.position.avgPrice)})`);
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  investCmd.command("sell <amount> <asset>").description('Sell USD amount of an asset (or "all")').option("--key <path>", "Key file path").option("--slippage <pct>", "Max slippage percent", "3").action(async (amount, asset, opts) => {
+    try {
+      const isAll = amount.toLowerCase() === "all";
+      if (!isAll) {
+        const parsed = parseFloat(amount);
+        if (isNaN(parsed) || parsed <= 0 || !isFinite(parsed)) {
+          console.error(pc13.red("  \u2717 Amount must be greater than $0"));
+          process.exitCode = 1;
+          return;
+        }
+      }
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const usdAmount = isAll ? "all" : parseFloat(amount);
+      const result = await agent.investSell({
+        asset: asset.toUpperCase(),
+        usdAmount,
+        maxSlippage: parseFloat(opts.slippage) / 100
+      });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      const sym = asset.toUpperCase();
+      printSuccess(`Sold ${formatAssetAmount(result.amount, sym)} ${sym} at ${formatUsd15(result.price)}`);
+      printKeyValue("Proceeds", formatUsd15(result.usdValue));
+      if (result.realizedPnL !== void 0) {
+        const pnlColor = result.realizedPnL >= 0 ? pc13.green : pc13.red;
+        const pnlSign = result.realizedPnL >= 0 ? "+" : "";
+        printKeyValue("Realized P&L", pnlColor(`${pnlSign}${formatUsd15(result.realizedPnL)}`));
+      }
+      if (result.position.totalAmount > 0) {
+        printKeyValue("Remaining", `${formatAssetAmount(result.position.totalAmount, sym)} ${sym} (avg ${formatUsd15(result.position.avgPrice)})`);
+      }
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  investCmd.command("earn <asset>").description("Deposit invested asset into best-rate lending protocol").option("--key <path>", "Key file path").option("--protocol <name>", "Force a specific protocol (navi, suilend)").action(async (asset, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const result = await agent.investEarn({
+        asset: asset.toUpperCase(),
+        protocol: opts.protocol?.toLowerCase()
+      });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      const sym = asset.toUpperCase();
+      if (result.amount === 0 && !result.tx) {
+        printSuccess(`${sym} is already fully earning via ${result.protocol} (${result.apy.toFixed(1)}% APY)`);
+      } else {
+        printSuccess(`${sym} deposited into ${result.protocol} (${result.apy.toFixed(1)}% APY)`);
+        printKeyValue("Amount", `${formatAssetAmount(result.amount, sym)} ${sym}`);
+        printKeyValue("Protocol", result.protocol);
+        printKeyValue("APY", `${result.apy.toFixed(2)}%`);
+        printKeyValue("Tx", explorerUrl(result.tx));
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  investCmd.command("unearn <asset>").description("Withdraw invested asset from lending (keeps in portfolio)").option("--key <path>", "Key file path").action(async (asset, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const result = await agent.investUnearn({
+        asset: asset.toUpperCase()
+      });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      const sym = asset.toUpperCase();
+      printSuccess(`Withdrew ${formatAssetAmount(result.amount, sym)} ${sym} from ${result.protocol}`);
+      printKeyValue("Status", `${sym} remains in investment portfolio (locked)`);
+      printKeyValue("Tx", explorerUrl(result.tx));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  investCmd.command("rebalance").description("Move earning positions to better-rate protocols").option("--key <path>", "Key file path").option("--dry-run", "Preview moves without executing").option("--min-diff <pct>", "Minimum APY difference to trigger move", "0.1").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const result = await agent.investRebalance({
+        dryRun: opts.dryRun,
+        minYieldDiff: opts.minDiff ? parseFloat(opts.minDiff) : void 0
+      });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (result.moves.length === 0) {
+        printInfo("All earning positions are already on the best rate");
+        if (result.skipped.length > 0) {
+          for (const s of result.skipped) {
+            printLine(`  ${s.asset}: ${s.apy.toFixed(2)}% on ${s.protocol} (best: ${s.bestApy.toFixed(2)}% \u2014 ${s.reason.replace(/_/g, " ")})`);
+          }
+        }
+        printBlank();
+        return;
+      }
+      if (opts.dryRun) {
+        printHeader("Rebalance Preview");
+        for (const m of result.moves) {
+          printLine(`  ${m.asset}: ${m.fromProtocol} (${m.oldApy.toFixed(2)}%) \u2192 ${m.toProtocol} (${m.newApy.toFixed(2)}%)`);
+          printLine(`  Gain: +${(m.newApy - m.oldApy).toFixed(2)}% APY`);
+        }
+      } else {
+        printSuccess("Rebalanced earning positions");
+        printSeparator();
+        for (const m of result.moves) {
+          printLine(`  ${m.asset}: ${m.fromProtocol} (${m.oldApy.toFixed(2)}%) \u2192 ${m.toProtocol} (${m.newApy.toFixed(2)}%)`);
+          printKeyValue("Amount", `${formatAssetAmount(m.amount, m.asset)} ${m.asset}`);
+          printKeyValue("APY gain", `+${(m.newApy - m.oldApy).toFixed(2)}%`);
+          if (m.txDigests.length > 0) {
+            printKeyValue("Tx", explorerUrl(m.txDigests[m.txDigests.length - 1]));
+          }
+        }
+        printSeparator();
+        printKeyValue("Gas", `${result.totalGasCost.toFixed(6)} SUI`);
+      }
+      if (result.skipped.length > 0) {
+        printBlank();
+        for (const s of result.skipped) {
+          printLine(`  ${s.asset}: kept on ${s.protocol} (${s.reason.replace(/_/g, " ")})`);
+        }
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  const strategyCmd = investCmd.command("strategy").description("Manage investment strategies");
+  strategyCmd.command("list").description("List available strategies").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const all = agent.strategies.getAll();
+      if (isJsonMode()) {
+        printJson(all);
+        return;
+      }
+      printBlank();
+      printHeader("Investment Strategies");
+      printSeparator();
+      for (const [key, def] of Object.entries(all)) {
+        const allocs = Object.entries(def.allocations).map(([a, p]) => `${a} ${p}%`).join(", ");
+        const tag = def.custom ? pc13.dim(" (custom)") : "";
+        printKeyValue(key, `${allocs}${tag}`);
+        printLine(`    ${pc13.dim(def.description)}`);
+      }
+      printSeparator();
+      const hasPositions = Object.keys(all).some((k) => agent.portfolio.hasStrategyPositions(k));
+      if (!hasPositions) {
+        printInfo("Buy into a strategy: t2000 invest strategy buy bluechip 100");
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("buy <name> <amount>").description("Buy into a strategy").option("--key <path>", "Key file path").option("--dry-run", "Preview allocation without executing").action(async (name, amount, opts) => {
+    try {
+      const parsed = parseFloat(amount);
+      if (isNaN(parsed) || parsed <= 0) {
+        console.error(pc13.red("  \u2717 Amount must be greater than $0"));
+        process.exitCode = 1;
+        return;
+      }
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const result = await agent.investStrategy({ strategy: name.toLowerCase(), usdAmount: parsed, dryRun: opts.dryRun });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (opts.dryRun) {
+        printHeader(`Strategy: ${name} \u2014 Dry Run (${formatUsd15(parsed)})`);
+        printSeparator();
+        for (const buy of result.buys) {
+          printKeyValue(buy.asset, `${formatUsd15(buy.usdAmount)} \u2192 ~${formatAssetAmount(buy.amount, buy.asset)} ${buy.asset} @ ${formatUsd15(buy.price)}`);
+        }
+        printSeparator();
+        printInfo("Run without --dry-run to execute");
+      } else {
+        const txDigests = [...new Set(result.buys.map((b) => b.tx))];
+        const isSingleTx = txDigests.length === 1;
+        printSuccess(`Invested ${formatUsd15(parsed)} in ${name} strategy`);
+        printSeparator();
+        for (const buy of result.buys) {
+          printKeyValue(buy.asset, `${formatAssetAmount(buy.amount, buy.asset)} @ ${formatUsd15(buy.price)}`);
+        }
+        printSeparator();
+        printKeyValue("Total invested", formatUsd15(result.totalInvested));
+        if (isSingleTx) {
+          printKeyValue("Tx", explorerUrl(txDigests[0]));
+        } else {
+          for (const buy of result.buys) {
+            printLine(`  ${pc13.dim(`${buy.asset}: ${explorerUrl(buy.tx)}`)}`);
+          }
+        }
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("sell <name>").description("Sell all positions in a strategy").option("--key <path>", "Key file path").action(async (name, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const result = await agent.sellStrategy({ strategy: name.toLowerCase() });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printSuccess(`Sold all ${name} strategy positions`);
+      printSeparator();
+      for (const sell of result.sells) {
+        const pnlColor = sell.realizedPnL >= 0 ? pc13.green : pc13.red;
+        const pnlSign = sell.realizedPnL >= 0 ? "+" : "";
+        printKeyValue(sell.asset, `${formatAssetAmount(sell.amount, sell.asset)} \u2192 ${formatUsd15(sell.usdValue)}  ${pnlColor(`${pnlSign}${formatUsd15(sell.realizedPnL)}`)}`);
+      }
+      if (result.failed && result.failed.length > 0) {
+        for (const f of result.failed) {
+          console.error(pc13.yellow(`  \u26A0 ${f.asset}: ${f.reason}`));
+        }
+      }
+      printSeparator();
+      printKeyValue("Total proceeds", formatUsd15(result.totalProceeds));
+      const rpnlColor = result.realizedPnL >= 0 ? pc13.green : pc13.red;
+      const rpnlSign = result.realizedPnL >= 0 ? "+" : "";
+      printKeyValue("Realized P&L", rpnlColor(`${rpnlSign}${formatUsd15(result.realizedPnL)}`));
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("status <name>").description("Show current status and weights of a strategy").option("--key <path>", "Key file path").action(async (name, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const status = await agent.getStrategyStatus(name.toLowerCase());
+      if (isJsonMode()) {
+        printJson(status);
+        return;
+      }
+      printBlank();
+      printHeader(`Strategy: ${status.definition.name}`);
+      printSeparator();
+      if (status.positions.length === 0) {
+        printInfo("No positions yet. Buy in with: t2000 invest strategy buy " + name + " 100");
+      } else {
+        for (const pos of status.positions) {
+          const target = status.definition.allocations[pos.asset] ?? 0;
+          const actual = status.currentWeights[pos.asset] ?? 0;
+          const drift = actual - target;
+          const driftColor = Math.abs(drift) > 3 ? pc13.yellow : pc13.dim;
+          const pnlColor = pos.unrealizedPnL >= 0 ? pc13.green : pc13.red;
+          const pnlSign = pos.unrealizedPnL >= 0 ? "+" : "";
+          printKeyValue(
+            pos.asset,
+            `${formatAssetAmount(pos.totalAmount, pos.asset)}  ${formatUsd15(pos.currentValue)}  ${pnlColor(`${pnlSign}${formatUsd15(pos.unrealizedPnL)}`)}  ${driftColor(`${actual.toFixed(0)}% / ${target}% target`)}`
+          );
+        }
+        printSeparator();
+        printKeyValue("Total value", formatUsd15(status.totalValue));
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("rebalance <name>").description("Rebalance a strategy to target weights").option("--key <path>", "Key file path").action(async (name, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const result = await agent.rebalanceStrategy({ strategy: name.toLowerCase() });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (result.trades.length === 0) {
+        printInfo(`Strategy '${name}' is already balanced (within 3% threshold)`);
+      } else {
+        printSuccess(`Rebalanced ${name} strategy`);
+        printSeparator();
+        for (const t of result.trades) {
+          const action = t.action === "buy" ? pc13.green("BUY") : pc13.red("SELL");
+          printKeyValue(t.asset, `${action} ${formatUsd15(t.usdAmount)} (${formatAssetAmount(t.amount, t.asset)})`);
+        }
+        printSeparator();
+        printInfo("Weights: " + Object.entries(result.afterWeights).map(([a, w]) => `${a} ${w.toFixed(0)}%`).join(", "));
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("create <name>").description("Create a custom strategy").requiredOption("--alloc <pairs...>", "Allocations e.g. SUI:40 BTC:20 ETH:20 GOLD:20").option("--description <desc>", "Strategy description").action(async (name, opts) => {
+    try {
+      const allocations = {};
+      for (const pair of opts.alloc) {
+        const [asset, pctStr] = pair.split(":");
+        if (!asset || !pctStr) {
+          console.error(pc13.red(`  \u2717 Invalid allocation: '${pair}'. Use ASSET:PCT format (e.g. SUI:60)`));
+          process.exitCode = 1;
+          return;
+        }
+        allocations[asset.toUpperCase()] = parseFloat(pctStr);
+      }
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin });
+      const definition = agent.strategies.create({ name, allocations, description: opts.description });
+      if (isJsonMode()) {
+        printJson(definition);
+        return;
+      }
+      printBlank();
+      printSuccess(`Created strategy '${name}'`);
+      const allocs = Object.entries(definition.allocations).map(([a, p]) => `${a} ${p}%`).join(", ");
+      printKeyValue("Allocations", allocs);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  strategyCmd.command("delete <name>").description("Delete a custom strategy").option("--key <path>", "Key file path").action(async (name, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      if (agent.portfolio.hasStrategyPositions(name.toLowerCase())) {
+        console.error(pc13.red(`  \u2717 Strategy '${name}' has open positions. Sell first: t2000 invest strategy sell ${name}`));
+        process.exitCode = 1;
+        return;
+      }
+      agent.strategies.delete(name.toLowerCase());
+      if (isJsonMode()) {
+        printJson({ deleted: name });
+        return;
+      }
+      printBlank();
+      printSuccess(`Deleted strategy '${name}'`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  const autoCmd = investCmd.command("auto").description("Dollar-cost averaging (DCA) schedules");
+  autoCmd.command("setup <amount> <frequency> [target]").description("Create a DCA schedule (target = strategy name or asset)").option("--key <path>", "Key file path").option("--day <num>", "Day of week (1-7) or month (1-28)").action(async (amount, frequency, target, opts) => {
+    try {
+      const parsed = parseFloat(amount);
+      if (isNaN(parsed) || parsed < 1) {
+        console.error(pc13.red("  \u2717 Amount must be at least $1"));
+        process.exitCode = 1;
+        return;
+      }
+      if (!["daily", "weekly", "monthly"].includes(frequency)) {
+        console.error(pc13.red("  \u2717 Frequency must be daily, weekly, or monthly"));
+        process.exitCode = 1;
+        return;
+      }
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const allStrategies = agent.strategies.getAll();
+      const isStrategy = target ? target.toLowerCase() in allStrategies : false;
+      const isAsset = target ? target.toUpperCase() in INVESTMENT_ASSETS2 : false;
+      if (target && !isStrategy && !isAsset) {
+        console.error(pc13.red(`  \u2717 '${target}' is not a valid strategy or asset`));
+        process.exitCode = 1;
+        return;
+      }
+      const dayNum = opts.day ? parseInt(opts.day, 10) : void 0;
+      const schedule = agent.setupAutoInvest({
+        amount: parsed,
+        frequency,
+        strategy: isStrategy ? target.toLowerCase() : void 0,
+        asset: isAsset ? target.toUpperCase() : void 0,
+        dayOfWeek: frequency === "weekly" ? dayNum : void 0,
+        dayOfMonth: frequency === "monthly" ? dayNum : void 0
+      });
+      if (isJsonMode()) {
+        printJson(schedule);
+        return;
+      }
+      printBlank();
+      const targetLabel = schedule.strategy ?? schedule.asset ?? "unknown";
+      printSuccess(`Auto-invest created: ${formatUsd15(schedule.amount)} ${schedule.frequency} \u2192 ${targetLabel}`);
+      printKeyValue("Schedule ID", schedule.id);
+      printKeyValue("Next run", new Date(schedule.nextRun).toLocaleDateString());
+      printInfo("Run manually: t2000 invest auto run");
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  autoCmd.command("status").description("Show all DCA schedules").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const status = agent.getAutoInvestStatus();
+      if (isJsonMode()) {
+        printJson(status);
+        return;
+      }
+      printBlank();
+      if (status.schedules.length === 0) {
+        printInfo("No auto-invest schedules. Set one up: t2000 invest auto setup 50 weekly bluechip");
+        printBlank();
+        return;
+      }
+      printHeader("Auto-Invest Schedules");
+      printSeparator();
+      for (const s of status.schedules) {
+        const target = s.strategy ?? s.asset ?? "?";
+        const statusTag = s.enabled ? pc13.green("active") : pc13.dim("paused");
+        printKeyValue(s.id, `${formatUsd15(s.amount)} ${s.frequency} \u2192 ${target}  ${statusTag}`);
+        printLine(`    ${pc13.dim(`Next: ${new Date(s.nextRun).toLocaleDateString()} \xB7 Runs: ${s.runCount} \xB7 Total: ${formatUsd15(s.totalInvested)}`)}`);
+      }
+      printSeparator();
+      if (status.pendingRuns.length > 0) {
+        printInfo(`${status.pendingRuns.length} pending run(s). Execute: t2000 invest auto run`);
+      } else {
+        printInfo("All schedules up to date");
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  autoCmd.command("run").description("Execute pending DCA purchases").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      const status = agent.getAutoInvestStatus();
+      if (status.pendingRuns.length === 0) {
+        if (isJsonMode()) {
+          printJson({ executed: [], skipped: [] });
+          return;
+        }
+        printBlank();
+        printInfo("No pending auto-invest runs. All schedules are up to date.");
+        printBlank();
+        return;
+      }
+      const result = await agent.runAutoInvest();
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (result.executed.length > 0) {
+        printSuccess(`Executed ${result.executed.length} auto-invest run(s)`);
+        for (const exec2 of result.executed) {
+          const target = exec2.strategy ?? exec2.asset ?? "?";
+          printKeyValue(target, formatUsd15(exec2.amount));
+        }
+      }
+      if (result.skipped.length > 0) {
+        for (const skip of result.skipped) {
+          printLine(`  ${pc13.yellow("\u26A0")} Skipped ${skip.scheduleId}: ${skip.reason}`);
+        }
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  autoCmd.command("stop <id>").description("Stop an auto-invest schedule").option("--key <path>", "Key file path").action(async (id, opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200024.create({ pin, keyPath: opts.key });
+      agent.stopAutoInvest(id);
+      if (isJsonMode()) {
+        printJson({ stopped: id });
+        return;
+      }
+      printBlank();
+      printSuccess(`Stopped auto-invest schedule ${id}`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/portfolio.ts
+import pc14 from "picocolors";
+import { T2000 as T200025, formatUsd as formatUsd16, formatAssetAmount as formatAssetAmount2 } from "@t2000/sdk";
+function printPositionLine(pos, rewardKeys) {
+  if (pos.currentPrice === 0 && pos.totalAmount > 0) {
+    printKeyValue(
+      pos.asset,
+      `${formatAssetAmount2(pos.totalAmount, pos.asset)}    Avg: ${formatUsd16(pos.avgPrice)}    Now: ${pc14.yellow("unavailable")}`
+    );
+  } else {
+    const pnlColor = pos.unrealizedPnL >= 0 ? pc14.green : pc14.red;
+    const pnlSign = pos.unrealizedPnL >= 0 ? "+" : "";
+    let yieldSuffix = "";
+    if (pos.earning && pos.earningApy) {
+      const hasRewards = rewardKeys?.has(`${pos.earningProtocol}:${pos.asset}`);
+      const rewardTag = hasRewards ? ` ${pc14.yellow("+rewards")}` : "";
+      yieldSuffix = `    ${pc14.cyan(`${pos.earningApy.toFixed(1)}% APY (${pos.earningProtocol})`)}${rewardTag}`;
+    }
+    printKeyValue(
+      pos.asset,
+      `${formatAssetAmount2(pos.totalAmount, pos.asset)}    Avg: ${formatUsd16(pos.avgPrice)}    Now: ${formatUsd16(pos.currentPrice)}    ${pnlColor(`${pnlSign}${formatUsd16(pos.unrealizedPnL)} (${pnlSign}${pos.unrealizedPnLPct.toFixed(1)}%)`)}${yieldSuffix}`
+    );
+  }
+}
+function registerPortfolio(program2) {
+  program2.command("portfolio").description("Show investment portfolio").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200025.create({ pin, keyPath: opts.key });
+      const portfolio = await agent.getPortfolio();
+      if (isJsonMode()) {
+        printJson(portfolio);
+        return;
+      }
+      const rewardKeys = /* @__PURE__ */ new Set();
+      try {
+        const pending = await agent.getPendingRewards();
+        for (const r of pending) rewardKeys.add(`${r.protocol}:${r.asset}`);
+      } catch {
+      }
+      printBlank();
+      const hasDirectPositions = portfolio.positions.length > 0;
+      const hasStrategyPositions = portfolio.strategyPositions && Object.keys(portfolio.strategyPositions).length > 0;
+      if (!hasDirectPositions && !hasStrategyPositions) {
+        printInfo("No investments yet. Try: t2000 invest buy 100 SUI");
+        printBlank();
+        return;
+      }
+      printHeader("Investment Portfolio");
+      if (hasStrategyPositions) {
+        for (const [key, positions] of Object.entries(portfolio.strategyPositions)) {
+          let stratLabel = key;
+          try {
+            const def = agent.strategies.get(key);
+            stratLabel = def.name;
+          } catch {
+          }
+          printLine(`  ${pc14.bold(pc14.cyan(`\u25B8 ${stratLabel}`))}`);
+          printSeparator();
+          for (const pos of positions) {
+            printPositionLine(pos, rewardKeys);
+          }
+          const stratValue = positions.reduce((s, p) => s + p.currentValue, 0);
+          printLine(`  ${pc14.dim(`Subtotal: ${formatUsd16(stratValue)}`)}`);
+          printBlank();
+        }
+      }
+      if (hasDirectPositions) {
+        if (hasStrategyPositions) {
+          printLine(`  ${pc14.bold(pc14.cyan("\u25B8 Direct"))}`);
+        }
+        printSeparator();
+        for (const pos of portfolio.positions) {
+          printPositionLine(pos, rewardKeys);
+        }
+        if (hasStrategyPositions) {
+          const directValue = portfolio.positions.reduce((s, p) => s + p.currentValue, 0);
+          printLine(`  ${pc14.dim(`Subtotal: ${formatUsd16(directValue)}`)}`);
+        }
+      }
+      printSeparator();
+      const hasPriceUnavailable = portfolio.positions.some((p) => p.currentPrice === 0 && p.totalAmount > 0);
+      if (hasPriceUnavailable) {
+        printInfo(pc14.yellow("\u26A0 Price data unavailable for some assets. Values may be inaccurate."));
+      }
+      printKeyValue("Total invested", formatUsd16(portfolio.totalInvested));
+      printKeyValue("Current value", formatUsd16(portfolio.totalValue));
+      const upnlColor = portfolio.unrealizedPnL >= 0 ? pc14.green : pc14.red;
+      const upnlSign = portfolio.unrealizedPnL >= 0 ? "+" : "";
+      printKeyValue("Unrealized P&L", upnlColor(`${upnlSign}${formatUsd16(portfolio.unrealizedPnL)} (${upnlSign}${portfolio.unrealizedPnLPct.toFixed(1)}%)`));
+      if (portfolio.realizedPnL !== 0) {
+        const rpnlColor = portfolio.realizedPnL >= 0 ? pc14.green : pc14.red;
+        const rpnlSign = portfolio.realizedPnL >= 0 ? "+" : "";
+        printKeyValue("Realized P&L", rpnlColor(`${rpnlSign}${formatUsd16(portfolio.realizedPnL)}`));
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/claimRewards.ts
+import pc15 from "picocolors";
+import { T2000 as T200026, formatUsd as formatUsd17 } from "@t2000/sdk";
+function registerClaimRewards(program2) {
+  program2.command("claim-rewards").description("Claim pending protocol rewards").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200026.create({ pin, keyPath: opts.key });
+      const result = await agent.claimRewards();
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      if (result.rewards.length === 0) {
+        printLine(`  ${pc15.dim("No rewards to claim")}`);
+        printBlank();
+        return;
+      }
+      const protocols = [...new Set(result.rewards.map((r) => r.protocol))];
+      printLine(`  ${pc15.green("\u2713")} Claimed and converted rewards to USDC`);
+      printSeparator();
+      const received = result.usdcReceived;
+      if (received >= 0.01) {
+        printKeyValue("Received", `${pc15.green(formatUsd17(received))} USDC`);
+      } else if (received > 0) {
+        printKeyValue("Received", `${pc15.green("< $0.01")} USDC`);
+      } else {
+        printKeyValue("Received", `${pc15.dim("< $0.01 USDC (rewards are still accruing)")}`);
+      }
+      printKeyValue("Source", protocols.join(", "));
+      if (result.tx) {
+        printKeyValue("Tx", `https://suiscan.xyz/mainnet/tx/${result.tx}`);
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
+// src/commands/gateway.ts
+import pc16 from "picocolors";
+import { T2000 as T200027 } from "@t2000/sdk";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync4, unlinkSync } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir8, platform as platform2 } from "os";
+import { execSync } from "child_process";
+var PLIST_LABEL = "com.t2000.gateway";
+var SYSTEMD_UNIT = "t2000-gateway";
+function getLaunchAgentPath() {
+  return join6(homedir8(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+}
+function getSystemdPath() {
+  return join6(homedir8(), ".config", "systemd", "user", `${SYSTEMD_UNIT}.service`);
+}
+function getLogDir() {
+  return join6(homedir8(), ".t2000", "logs");
+}
+function getT2000Bin() {
+  try {
+    return execSync("which t2000", { encoding: "utf-8" }).trim();
+  } catch {
+    return "npx t2000";
+  }
+}
+function registerGateway(program2) {
+  const gw = program2.command("gateway").description("Start AI financial advisor gateway");
+  gw.command("start", { isDefault: true }).description("Start the gateway (foreground)").option("--port <port>", "WebChat port", "2000").option("--no-telegram", "Skip Telegram channel").option("--no-heartbeat", "Skip heartbeat daemon").option("--verbose", "Debug logging").option("--key <path>", "Key file path").action(async (opts) => {
+    try {
+      const pin = await resolvePin();
+      const agent = await T200027.create({ pin, keyPath: opts.key });
+      console.log("");
+      console.log(`  ${pc16.bold("t2000 gateway")}`);
+      console.log("");
+      const { Gateway } = await import("./dist-IHO4UPEB.js");
+      const gateway = await Gateway.create({
+        agent,
+        port: parseInt(opts.port, 10),
+        noTelegram: !opts.telegram,
+        noHeartbeat: !opts.heartbeat,
+        verbose: opts.verbose
+      });
+      const info = await gateway.start();
+      const truncAddr = info.address.slice(0, 6) + "..." + info.address.slice(-4);
+      printSuccess(`Agent unlocked (${truncAddr})`);
+      printSuccess(`${info.llmProvider === "anthropic" ? "Claude" : "GPT"} connected (${info.llmModel})`);
+      if (info.telegramConnected) printSuccess("Telegram connected");
+      if (info.webchatUrl) printSuccess(`WebChat at ${pc16.underline(info.webchatUrl)}`);
+      if (info.heartbeatTasks > 0) printSuccess(`Heartbeat started (${info.heartbeatTasks} tasks)`);
+      printSuccess("Ready \u2014 talk to your agent");
+      console.log("");
+      await new Promise(() => {
+      });
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  gw.command("status").description("Check if gateway is running").option("--port <port>", "WebChat port to check", "2000").action(async (opts) => {
+    try {
+      const port = parseInt(opts.port, 10);
+      const response = await fetch(`http://127.0.0.1:${port}/health`);
+      if (response.ok) {
+        const data = await response.json();
+        printSuccess(`Gateway is running on port ${port} (${data.status})`);
+      }
+    } catch {
+      console.log(`  ${pc16.yellow("\u25CB")} Gateway is not running on port ${opts.port}`);
+    }
+  });
+  gw.command("install").description("Install gateway as a background daemon").option("--port <port>", "WebChat port", "2000").action(async (opts) => {
+    try {
+      const os = platform2();
+      const bin = getT2000Bin();
+      if (os === "darwin") {
+        installLaunchd(bin, opts.port);
+      } else if (os === "linux") {
+        installSystemd(bin, opts.port);
+      } else {
+        throw new Error(`Unsupported platform: ${os}. Use macOS or Linux.`);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  gw.command("uninstall").description("Remove gateway daemon").action(async () => {
+    try {
+      const os = platform2();
+      if (os === "darwin") {
+        uninstallLaunchd();
+      } else if (os === "linux") {
+        uninstallSystemd();
+      } else {
+        throw new Error(`Unsupported platform: ${os}`);
+      }
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  gw.command("logs").description("Tail gateway logs").option("-n <lines>", "Number of lines", "50").option("-f, --follow", "Follow log output").action(async (opts) => {
+    try {
+      const logPath = join6(getLogDir(), "gateway.log");
+      if (!existsSync5(logPath)) {
+        printWarning("No gateway logs found yet.");
+        printInfo(`Log path: ${logPath}`);
+        return;
+      }
+      printBlank();
+      printInfo(`Log file: ${logPath}`);
+      printBlank();
+      const content = readFileSync4(logPath, "utf-8");
+      const lines = content.trim().split("\n");
+      const tail = lines.slice(-parseInt(opts.n, 10));
+      for (const line of tail) {
+        try {
+          const entry = JSON.parse(line);
+          const time = new Date(entry.ts).toLocaleTimeString();
+          const levelColor = entry.level === "error" ? pc16.red : entry.level === "warn" ? pc16.yellow : pc16.dim;
+          printLine(`${pc16.dim(time)} ${levelColor(entry.level.padEnd(5))} ${entry.msg}`);
+        } catch {
+          printLine(line);
+        }
+      }
+      if (opts.follow) {
+        printBlank();
+        printInfo("Following... (Ctrl+C to stop)");
+        const { spawn } = await import("child_process");
+        const child = spawn("tail", ["-f", logPath], { stdio: "inherit" });
+        process.on("SIGINT", () => {
+          child.kill();
+          process.exit(0);
+        });
+        await new Promise(() => {
+        });
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+function installLaunchd(bin, port) {
+  const logDir = getLogDir();
+  const plistPath = getLaunchAgentPath();
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${bin}</string>
+    <string>gateway</string>
+    <string>start</string>
+    <string>--port</string>
+    <string>${port}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logDir}/gateway-stdout.log</string>
+  <key>StandardErrorPath</key>
+  <string>${logDir}/gateway-stderr.log</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+  </dict>
+</dict>
+</plist>`;
+  if (existsSync5(plistPath)) {
+    try {
+      execSync(`launchctl unload "${plistPath}" 2>/dev/null`);
+    } catch {
+    }
+  }
+  writeFileSync4(plistPath, plist);
+  execSync(`launchctl load "${plistPath}"`);
+  printBlank();
+  printSuccess("Gateway daemon installed");
+  printSuccess(`Starts on boot \u2014 runs in background`);
+  printLine(`  ${pc16.dim("Logs:")} ${logDir}/gateway.log`);
+  printLine(`  ${pc16.dim("Stop:")} t2000 gateway uninstall`);
+  printBlank();
+}
+function uninstallLaunchd() {
+  const plistPath = getLaunchAgentPath();
+  if (!existsSync5(plistPath)) {
+    printWarning("Gateway daemon is not installed.");
+    return;
+  }
+  try {
+    execSync(`launchctl unload "${plistPath}" 2>/dev/null`);
+  } catch {
+  }
+  unlinkSync(plistPath);
+  printBlank();
+  printSuccess("Gateway daemon removed");
+  printBlank();
+}
+function installSystemd(bin, port) {
+  const logDir = getLogDir();
+  const unitPath = getSystemdPath();
+  const unitDir = join6(homedir8(), ".config", "systemd", "user");
+  const unit = `[Unit]
+Description=t2000 Gateway \u2014 AI Financial Advisor
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${bin} gateway start --port ${port}
+Restart=on-failure
+RestartSec=10
+StandardOutput=append:${logDir}/gateway-stdout.log
+StandardError=append:${logDir}/gateway-stderr.log
+
+[Install]
+WantedBy=default.target
+`;
+  if (!existsSync5(unitDir)) {
+    execSync(`mkdir -p "${unitDir}"`);
+  }
+  writeFileSync4(unitPath, unit);
+  execSync("systemctl --user daemon-reload");
+  execSync(`systemctl --user enable ${SYSTEMD_UNIT}`);
+  execSync(`systemctl --user start ${SYSTEMD_UNIT}`);
+  printBlank();
+  printSuccess("Gateway daemon installed (systemd)");
+  printSuccess("Starts on login \u2014 runs in background");
+  printLine(`  ${pc16.dim("Logs:")} ${logDir}/gateway.log`);
+  printLine(`  ${pc16.dim("Status:")} systemctl --user status ${SYSTEMD_UNIT}`);
+  printLine(`  ${pc16.dim("Stop:")} t2000 gateway uninstall`);
+  printBlank();
+}
+function uninstallSystemd() {
+  const unitPath = getSystemdPath();
+  if (!existsSync5(unitPath)) {
+    printWarning("Gateway daemon is not installed.");
+    return;
+  }
+  try {
+    execSync(`systemctl --user stop ${SYSTEMD_UNIT} 2>/dev/null`);
+  } catch {
+  }
+  try {
+    execSync(`systemctl --user disable ${SYSTEMD_UNIT} 2>/dev/null`);
+  } catch {
+  }
+  unlinkSync(unitPath);
+  try {
+    execSync("systemctl --user daemon-reload");
+  } catch {
+  }
+  printBlank();
+  printSuccess("Gateway daemon removed");
+  printBlank();
+}
+
+// src/program.ts
+var require2 = createRequire(import.meta.url);
+var { version: CLI_VERSION } = require2("../package.json");
+function createProgram() {
+  const program2 = new Command();
+  program2.name("t2000").description("Your personal AI financial advisor").version(`${CLI_VERSION} (beta)`).option("--json", "Output in JSON format").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    if (opts.json) setJsonMode(true);
+  });
+  registerInit(program2);
+  registerSend(program2);
+  registerBalance(program2);
+  registerAddress(program2);
+  registerDeposit(program2);
+  registerHistory(program2);
+  registerExport(program2);
+  registerImport(program2);
+  registerSave(program2);
+  registerWithdraw(program2);
+  registerBorrow(program2);
+  registerRepay(program2);
+  registerHealth(program2);
+  registerRates(program2);
+  registerPositions(program2);
+  registerEarnings(program2);
+  registerFundStatus(program2);
+  registerConfig(program2);
+  registerServe(program2);
+  registerPay(program2);
+  registerLock(program2);
+  registerSentinel(program2);
+  registerEarn(program2);
+  registerRebalance(program2);
+  registerExchange(program2);
+  registerMcp(program2);
+  registerContacts(program2);
+  registerInvest(program2);
+  registerPortfolio(program2);
+  registerClaimRewards(program2);
+  registerGateway(program2);
+  return program2;
+}
+
+// src/index.ts
+var program = createProgram();
 program.parse();
 //# sourceMappingURL=index.js.map