@hedge-layer/cli 1.5.0 → 1.7.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command2 } from "commander";
+import { Command as Command4 } from "commander";
 
 // src/commands/auth.ts
 import readline from "readline/promises";
@@ -300,7 +300,7 @@ function registerAuthCommands(program2) {
     try {
       heading("Hedge Layer CLI \u2014 Login");
       process.stderr.write(
-        `Create an API token at ${bold("https://hedgelayer.ai/settings")} \u2192 API Tokens
+        `Create an API token at ${bold("https://hedgelayer.ai/account/settings")} \u2192 API Tokens
 
 `
       );
@@ -1184,6 +1184,13 @@ function parseNonNegative(value) {
   }
   return n;
 }
+function parsePositiveNumber(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new InvalidArgumentError("Expected a positive number");
+  }
+  return n;
+}
 function parsePositiveInt(value) {
   const n = Number(value);
   if (!Number.isInteger(n) || n < 1) {
@@ -1215,6 +1222,9 @@ function strategyFromOptions(opts) {
     id: "cli-dry-run",
     name: "CLI dry-run LP strategy",
     status: opts.paused ? "paused" : "dry_run",
+    ...opts.totalHoldings !== void 0 && { total_holdings: opts.totalHoldings },
+    ...opts.capitalLimitPct !== void 0 && { capital_limit_pct: opts.capitalLimitPct },
+    ...opts.perMarketLimitPct !== void 0 && { per_market_limit_pct: opts.perMarketLimitPct },
     capital_limit: opts.capitalLimit,
     per_market_limit: opts.perMarketLimit,
     min_expected_return_daily_pct: opts.minExpectedReturnDailyPct,
@@ -1227,6 +1237,15 @@ function strategyFromOptions(opts) {
     max_markets: opts.maxMarkets
   };
 }
+function validatePercentageSizing(opts) {
+  const usesPercentageSizing = opts.capitalLimitPct !== void 0 || opts.perMarketLimitPct !== void 0;
+  if (usesPercentageSizing && opts.totalHoldings === void 0) {
+    error(
+      "Percentage sizing requires --total-holdings so the allocator can convert percentages into dollar caps."
+    );
+    process.exit(1);
+  }
+}
 async function readAllocations(path) {
   if (!path) return [];
   const raw = path === "-" ? await readStdin() : await readFile(path, "utf8");
@@ -1252,10 +1271,11 @@ function registerAllocatorCommands(program2) {
     "[screening]",
     `Optional screening preset: ${PROFILE_CHOICES2.join(" | ")} (same as --profile)`,
     "lp-opportunity"
-  ).option("--profile <name>", `Screening defaults: ${PROFILE_CHOICES2.join(", ")}`).option("--sort-by <key>", "score | volume | liquidity | movement | spread | rewards | rewardYield | lpExpectedReturn | horizon").option("--tag <slug>", "Polymarket category tag, e.g. crypto, politics").option("--min-volume <usd>", "Minimum 24h volume (USD)").option("--min-liquidity <usd>", "Minimum displayed liquidity (USD)").option("--max-liquidity <usd>", "Maximum displayed liquidity (USD)").option("--min-rewards-daily-rate <usd>", "Minimum LP rewards USD/day").option("--min-days-to-end <n>", "Feed filter: minimum days until resolution").option("--max-days-to-end <n>", "Feed filter: maximum days until resolution").option("--max-market-age-hours <n>", "With liquid-new-or-long: max age for the new branch").option("--liquid-profile <mode>", "new-or-long (used by liquid-new-or-long screen)").option("--limit <n>", "Max feed markets to fetch (1-100, default 15)", "15").option("--capital-limit <usd>", "Portfolio capital limit for this cycle", parseNonNegative, 500).option("--per-market-limit <usd>", "Per-market target cap", parseNonNegative, 100).option("--min-expected-return-daily-pct <pct>", "Minimum expected daily return percent", parseNonNegative, 0.02).option("--max-inventory-imbalance <ratio>", "Maximum inventory imbalance", parseNonNegative, 0.25).option("--max-order-notional <usd>", "Maximum notional per planned passive order", parseNonNegative, 25).option("--quote-edge-bps <bps>", "Passive quote edge in basis points", parseNonNegative, 100).option("--allocator-min-liquidity <usd>", "Allocator safety gate: minimum market liquidity", parseNonNegative, 500).option("--max-spread <ratio>", "Allocator safety gate: maximum spread", parseNonNegative, 0.12).option("--allocator-min-days-to-end <n>", "Allocator safety gate: minimum days to resolution", parseNonNegative, 3).option("--max-markets <n>", "Maximum markets allocator may target", parsePositiveInt, 5).option("--allocations <file>", "Existing allocations JSON array; use '-' to read stdin").option("--repeat", "Run a second cycle using targets returned by the first cycle").option("--paused", "Send strategy status paused instead of dry_run").action(async (screening, o) => {
+  ).option("--profile <name>", `Screening defaults: ${PROFILE_CHOICES2.join(", ")}`).option("--sort-by <key>", "score | volume | liquidity | movement | spread | rewards | rewardYield | lpExpectedReturn | horizon").option("--tag <slug>", "Polymarket category tag, e.g. crypto, politics").option("--min-volume <usd>", "Minimum 24h volume (USD)").option("--min-liquidity <usd>", "Minimum displayed liquidity (USD)").option("--max-liquidity <usd>", "Maximum displayed liquidity (USD)").option("--min-rewards-daily-rate <usd>", "Minimum LP rewards USD/day").option("--min-days-to-end <n>", "Feed filter: minimum days until resolution").option("--max-days-to-end <n>", "Feed filter: maximum days until resolution").option("--max-market-age-hours <n>", "With liquid-new-or-long: max age for the new branch").option("--liquid-profile <mode>", "new-or-long (used by liquid-new-or-long screen)").option("--limit <n>", "Max feed markets to fetch (1-100, default 15)", "15").option("--total-holdings <usd>", "Total user holdings / portfolio value used for percentage sizing", parsePositiveNumber).option("--capital-limit-pct <pct>", "Portfolio-level allocation cap as a percent of total holdings", parsePositiveNumber).option("--per-market-limit-pct <pct>", "Per-market target cap as a percent of total holdings", parsePositiveNumber).option("--capital-limit <usd>", "Portfolio capital limit for this cycle", parseNonNegative, 500).option("--per-market-limit <usd>", "Per-market target cap", parseNonNegative, 100).option("--min-expected-return-daily-pct <pct>", "Minimum expected daily return percent", parseNonNegative, 0.02).option("--max-inventory-imbalance <ratio>", "Maximum inventory imbalance", parseNonNegative, 0.25).option("--max-order-notional <usd>", "Maximum notional per planned passive order", parseNonNegative, 25).option("--quote-edge-bps <bps>", "Passive quote edge in basis points", parseNonNegative, 100).option("--allocator-min-liquidity <usd>", "Allocator safety gate: minimum market liquidity", parseNonNegative, 500).option("--max-spread <ratio>", "Allocator safety gate: maximum spread", parseNonNegative, 0.12).option("--allocator-min-days-to-end <n>", "Allocator safety gate: minimum days to resolution", parseNonNegative, 3).option("--max-markets <n>", "Maximum markets allocator may target", parsePositiveInt, 5).option("--allocations <file>", "Existing allocations JSON array; use '-' to read stdin").option("--repeat", "Run a second cycle using targets returned by the first cycle").option("--paused", "Send strategy status paused instead of dry_run").action(async (screening, o) => {
     const globalOpts = program2.opts();
     const client = new ApiClient(globalOpts);
     requireAuth5(client);
+    validatePercentageSizing(o);
     let profile = o.profile ?? screening ?? "lp-opportunity";
     if (!isProfile2(profile)) {
       error(`Unknown screening "${profile}". Use: ${PROFILE_CHOICES2.join(" or ")}`);
@@ -1313,14 +1333,562 @@ function registerAllocatorCommands(program2) {
   });
 }
 
+// src/commands/lp.ts
+import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
+import { writeFile } from "fs/promises";
+
+// src/lp-display.ts
+import chalk7 from "chalk";
+function num2(value, fallback = 0) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+function signedCurrency2(value) {
+  const formatted = currency(Math.abs(value));
+  if (value > 0) return chalk7.green(`+${formatted}`);
+  if (value < 0) return chalk7.yellow(`-${formatted}`);
+  return chalk7.dim("$0.00");
+}
+function actionSummary(actions) {
+  if (!actions) return "none";
+  return Object.entries(actions).filter(([, count]) => num2(count) > 0).map(([action, count]) => `${action}:${num2(count)}`).join(" ");
+}
+function displayLpScanResult(result, globalOpts) {
+  if (globalOpts.json) {
+    json(result);
+    return;
+  }
+  heading("LP Scan");
+  process.stdout.write(
+    chalk7.dim(
+      `  scan ${result.scanId} \xB7 strategy ${result.strategyId} \xB7 ${result.evidenceSaved} evidence rows saved
+`
+    )
+  );
+  process.stdout.write(
+    chalk7.dim(
+      `  ${result.totalScanned.toLocaleString()} scanned \xB7 ${result.totalAfterFilter.toLocaleString()} after filters \xB7 profile ${result.profile}
+
+`
+    )
+  );
+  if (result.markets.length === 0) {
+    warn("No markets matched the LP scan.");
+    return;
+  }
+  table(
+    result.markets.slice(0, 10).map((market) => [
+      String(market.rank),
+      truncate(market.question, 46),
+      String(Math.round(num2(market.score))),
+      compactCurrency(num2(market.liquidity)),
+      compactCurrency(num2(market.rewardsDailyRate)) + "/day",
+      `${num2(market.lpExpectedReturnDailyPct).toFixed(3)}%`
+    ]),
+    ["#", "Market", "Score", "Liq", "Rewards", "Exp/day"]
+  );
+}
+function displayLpRecommendResult(result, globalOpts) {
+  if (globalOpts.json) {
+    json(result);
+    return;
+  }
+  heading("LP Recommendations");
+  process.stdout.write(
+    chalk7.dim(
+      `  cycle ${result.cycleId} \xB7 strategy ${result.strategyId} \xB7 ${result.candidatesSubmitted} markets \xB7 ${result.allocationsSubmitted} current allocations
+`
+    )
+  );
+  process.stdout.write(
+    chalk7.dim(
+      `  PnL context ${result.pnlContextCount} rows${result.pnlSynced ? " \xB7 synced" : ""} \xB7 approvals required
+
+`
+    )
+  );
+  displayAllocatorCycleResult(result.result ?? { decisions: result.decisions }, globalOpts);
+}
+function displayLpEvaluateResult(result, globalOpts) {
+  if (globalOpts.json) {
+    json(result);
+    return;
+  }
+  heading("LP Evaluation");
+  process.stdout.write(
+    chalk7.dim(
+      `  strategy ${result.strategyId} \xB7 ${result.summary.snapshots} snapshots \xB7 ${result.summary.markets} markets`
+    )
+  );
+  if (result.pnlSynced) process.stdout.write(chalk7.dim(" \xB7 synced"));
+  process.stdout.write("\n\n");
+  if (result.syncError) warn(result.syncError);
+  table(
+    [
+      ["Realized PnL", signedCurrency2(result.summary.realizedPnl)],
+      ["Unrealized PnL", signedCurrency2(result.summary.unrealizedPnl)],
+      ["Net PnL", signedCurrency2(result.summary.netPnl)],
+      ["Capital locked", currency(result.summary.capitalLocked)],
+      ["Current value", currency(result.summary.currentValue)],
+      ["Outcomes", actionSummary(result.summary.outcomes)]
+    ]
+  );
+  if (result.lessons.length === 0) {
+    warn("No PnL lessons available yet.");
+    return;
+  }
+  process.stdout.write("\n");
+  table(
+    result.lessons.slice(0, 8).map((lesson) => [
+      truncate(String(lesson.market_slug ?? "portfolio"), 26),
+      String(lesson.outcome ?? "flat"),
+      signedCurrency2(num2(lesson.net_pnl)),
+      truncate(String(lesson.lesson ?? "no lesson"), 64)
+    ]),
+    ["Market", "Outcome", "Net", "Lesson"]
+  );
+}
+function displayLpRunResult(result, globalOpts) {
+  if (globalOpts.json) {
+    json(result);
+    return;
+  }
+  heading("LP Run");
+  process.stdout.write(
+    chalk7.dim(
+      `  cycle ${result.run.cycleId} \xB7 scan ${result.run.scanId ?? "n/a"} \xB7 strategy ${result.run.strategyId}
+`
+    )
+  );
+  process.stdout.write(
+    chalk7.dim(
+      `  ${result.run.opportunitiesFound} opportunities \xB7 PnL ${result.run.pnlSynced ? "synced" : "not synced"} \xB7 approvals required
+
+`
+    )
+  );
+  displayAllocatorCycleResult(result.run.result, globalOpts);
+  if (result.evaluation) {
+    process.stdout.write("\n");
+    process.stdout.write(
+      chalk7.dim(
+        `  Evaluation: ${signedCurrency2(result.evaluation.summary.netPnl)} net PnL across ${result.evaluation.summary.markets} markets
+`
+      )
+    );
+  }
+}
+
+// src/commands/lp.ts
+function requireAuth6(client) {
+  if (!client.isAuthenticated) {
+    error("Not authenticated. Run `hl auth login` first.");
+    process.exit(1);
+  }
+}
+function parseNonNegative2(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) {
+    throw new InvalidArgumentError2("Expected a non-negative number");
+  }
+  return n;
+}
+function parsePositiveInt2(value) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1) {
+    throw new InvalidArgumentError2("Expected a positive integer");
+  }
+  return n;
+}
+function compact(payload) {
+  return Object.fromEntries(
+    Object.entries(payload).filter(([, value]) => value !== void 0 && value !== "")
+  );
+}
+async function writeArtifact(path, data, jsonMode) {
+  if (!path) return;
+  await writeFile(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+  if (!jsonMode) {
+    process.stderr.write(dim(`  Saved artifact to ${path}
+`));
+  }
+}
+function buildLpScanPayload(topic, opts) {
+  return compact({
+    topic: topic?.trim() || void 0,
+    strategyId: opts.strategyId,
+    profile: opts.profile,
+    sortBy: opts.sortBy,
+    tag: opts.tag,
+    minVolume: opts.minVolume,
+    minLiquidity: opts.minLiquidity,
+    maxLiquidity: opts.maxLiquidity,
+    minRewardsDailyRate: opts.minRewardsDailyRate,
+    minDaysToEnd: opts.minDaysToEnd,
+    maxDaysToEnd: opts.maxDaysToEnd,
+    maxMarketAgeHours: opts.maxMarketAgeHours,
+    liquidProfile: opts.liquidProfile,
+    limit: opts.limit
+  });
+}
+function buildLpRecommendPayload(opts) {
+  return compact({
+    strategyId: opts.strategyId,
+    scanId: opts.scanId,
+    limit: opts.limit,
+    syncPnl: opts.syncPnl
+  });
+}
+function buildLpEvaluatePayload(opts) {
+  return compact({
+    strategyId: opts.strategyId,
+    walletAddress: opts.walletAddress,
+    syncPnl: opts.syncPnl,
+    limit: opts.limit
+  });
+}
+function buildLpRunPayload(opts) {
+  return compact({
+    strategyId: opts.strategyId,
+    limit: opts.limit,
+    syncPnl: opts.syncPnl
+  });
+}
+function registerLpCommands(program2) {
+  const lp = program2.command("lp").description("Run persisted liquidity-provider scan, recommendation, and evaluation workflows");
+  lp.command("scan").description("Scan LP candidates and persist them as evidence").argument("[topic]", "Human label for this scan, e.g. liquidity opportunities").option("--profile <name>", "lp-opportunity | liquidity-provider | liquid-new-or-long", "liquidity-provider").option("--sort-by <key>", "score | volume | liquidity | movement | spread | rewards | rewardYield | lpExpectedReturn | horizon").option("--tag <slug>", "Polymarket category tag, e.g. crypto, politics").option("--min-volume <usd>", "Minimum 24h volume (USD)", parseNonNegative2).option("--min-liquidity <usd>", "Minimum displayed liquidity (USD)", parseNonNegative2).option("--max-liquidity <usd>", "Maximum displayed liquidity (USD)", parseNonNegative2).option("--min-rewards-daily-rate <usd>", "Minimum LP rewards USD/day", parseNonNegative2).option("--min-days-to-end <n>", "Minimum days until resolution", parseNonNegative2).option("--max-days-to-end <n>", "Maximum days until resolution", parseNonNegative2).option("--max-market-age-hours <n>", "With liquid-new-or-long: max age for the new branch", parseNonNegative2).option("--liquid-profile <mode>", "new-or-long").option("--limit <n>", "Max markets to scan/save (1-100, default 15)", parsePositiveInt2, 15).option("--strategy-id <uuid>", "LP strategy id").option("--output <file>", "Write the evidence JSON response to a local file").action(async (topic, opts) => {
+    const globalOpts = program2.opts();
+    const client = new ApiClient(globalOpts);
+    requireAuth6(client);
+    const result = await client.post(
+      "/api/lp/scan",
+      buildLpScanPayload(topic, opts)
+    );
+    await writeArtifact(opts.output, result, Boolean(globalOpts.json));
+    displayLpScanResult(result, globalOpts);
+  });
+  lp.command("recommend").description("Run allocator recommendations from saved LP evidence and current allocations").option("--strategy-id <uuid>", "LP strategy id").option("--scan-id <uuid>", "Use candidates from a specific saved scan").option("--limit <n>", "Max saved candidates to submit (1-25, default 15)", parsePositiveInt2, 15).option("--sync-pnl", "Refresh wallet PnL before recommending").option("--output <file>", "Write the recommendation JSON response to a local file").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = new ApiClient(globalOpts);
+    requireAuth6(client);
+    const result = await client.post(
+      "/api/lp/recommend",
+      buildLpRecommendPayload(opts)
+    );
+    await writeArtifact(opts.output, result, Boolean(globalOpts.json));
+    displayLpRecommendResult(result, globalOpts);
+  });
+  lp.command("evaluate").description("Evaluate LP performance and return compact lessons").option("--strategy-id <uuid>", "LP strategy id").option("--wallet-address <address>", "Wallet address to sync PnL from").option("--no-sync-pnl", "Use existing PnL snapshots without refreshing").option("--limit <n>", "Max PnL snapshots to evaluate (1-100, default 50)", parsePositiveInt2, 50).option("--output <file>", "Write the evaluation JSON response to a local file").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = new ApiClient(globalOpts);
+    requireAuth6(client);
+    const result = await client.post(
+      "/api/lp/evaluate",
+      buildLpEvaluatePayload(opts)
+    );
+    await writeArtifact(opts.output, result, Boolean(globalOpts.json));
+    displayLpEvaluateResult(result, globalOpts);
+  });
+  lp.command("run").description("Run scan, recommendation, and evaluation as one dry-run chain").option("--strategy-id <uuid>", "LP strategy id").option("--limit <n>", "Max candidates to scan/recommend (1-25, default 15)", parsePositiveInt2, 15).option("--no-sync-pnl", "Use existing PnL snapshots without refreshing").option("--output <file>", "Write the chained run JSON response to a local file").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = new ApiClient(globalOpts);
+    requireAuth6(client);
+    const run = await client.post(
+      "/api/lp/run",
+      buildLpRunPayload(opts)
+    );
+    let evaluation = null;
+    try {
+      evaluation = await client.post("/api/lp/evaluate", {
+        strategyId: run.strategyId,
+        syncPnl: false
+      });
+    } catch (error2) {
+      if (!globalOpts.json) {
+        warn(
+          `Could not load evaluation summary: ${error2 instanceof Error ? error2.message : String(error2)}`
+        );
+      }
+    }
+    const combined = { run, evaluation };
+    await writeArtifact(opts.output, combined, Boolean(globalOpts.json));
+    displayLpRunResult(combined, globalOpts);
+  });
+}
+
+// src/commands/wallet.ts
+import { InvalidArgumentError as InvalidArgumentError3 } from "commander";
+import { spawn } from "child_process";
+var NETWORK_NAME = "Polygon";
+var POLYGON_NATIVE_USDC = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359";
+var SUPPORTED_ASSETS = ["pUsd", "usdcE", "matic"];
+var POLYGON_NATIVE_ASSET_LABEL = "POL";
+var TERMINAL_WITHDRAWAL_STATUSES = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled", "expired"]);
+function requireAuth7(client) {
+  if (!client.isAuthenticated) {
+    error("Not authenticated. Run `hl auth login` first.");
+    process.exit(1);
+  }
+}
+function parsePositiveNumber2(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new InvalidArgumentError3("Expected a positive number");
+  }
+  return n;
+}
+function parseWalletAddress(value) {
+  const trimmed = value.trim();
+  if (!/^0x[a-fA-F0-9]{40}$/.test(trimmed)) {
+    throw new InvalidArgumentError3("Expected a valid EVM wallet address");
+  }
+  return trimmed;
+}
+function normalizeWalletAsset(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase().replace(/[._\s-]/g, "");
+  if (["pusd", "polymarketusd"].includes(normalized)) return "pUsd";
+  if (["usdce", "usdcebridged", "bridgedusdc", "usdc"].includes(normalized)) return "usdcE";
+  if (["matic", "pol"].includes(normalized)) return "matic";
+  throw new InvalidArgumentError3("Unknown wallet asset. Use pUSD, USDC.e, or POL.");
+}
+function assetByKey(balances, key) {
+  return balances.assets[key];
+}
+function tokenAddress(asset) {
+  return asset.address ?? "native token";
+}
+function displayAmount(asset) {
+  if (!asset.ok) {
+    return `unavailable${asset.error ? ` (${asset.error})` : ""}`;
+  }
+  const numeric = Number(asset.balance);
+  if (asset.address === null && asset.decimals === 18) {
+    return Number.isFinite(numeric) ? numeric.toLocaleString("en-US", { maximumFractionDigits: 6 }) : asset.balance;
+  }
+  return Number.isFinite(numeric) ? currency(numeric) : asset.balance;
+}
+function displayAssetSymbol(asset) {
+  return asset.address === null && asset.decimals === 18 ? POLYGON_NATIVE_ASSET_LABEL : asset.symbol;
+}
+function buildDepositInstructions(balances, assetKey) {
+  const assets = assetKey ? [assetByKey(balances, assetKey)] : SUPPORTED_ASSETS.map((key) => assetByKey(balances, key));
+  return {
+    action: "deposit",
+    publicDepositAddress: balances.walletAddress,
+    walletAddress: balances.walletAddress,
+    chainId: balances.chainId,
+    network: NETWORK_NAME,
+    asset: assetKey ? assetByKey(balances, assetKey) : null,
+    assets,
+    warning: "Send only Polygon assets to this address. Hedge Layer cannot reverse external transfers."
+  };
+}
+function buildWithdrawRequestPayload(opts) {
+  const assetKey = normalizeWalletAsset(opts.asset) ?? "pUsd";
+  if (assetKey !== "pUsd") {
+    throw new InvalidArgumentError3("Bridge withdrawals currently send pUSD. Use --asset pUSD.");
+  }
+  return {
+    amount: opts.amount,
+    recipientAddress: opts.to,
+    toChainId: opts.toChainId ?? "137",
+    toTokenAddress: opts.toTokenAddress ?? POLYGON_NATIVE_USDC
+  };
+}
+function displayWalletStatus(status) {
+  const ownerWallet = status.ownerWallet ?? status.wallet;
+  const depositWallet = status.depositWallet ?? status.tradingWallet ?? null;
+  heading("Wallet");
+  table([
+    ["Owner linked", status.linked ? "yes" : "no"],
+    ["Provider", status.provider],
+    ["Owner wallet", ownerWallet?.wallet_address ?? "(none)"],
+    ["Owner chain", ownerWallet ? `${NETWORK_NAME} (${ownerWallet.chain_id})` : "(none)"],
+    ["Owner linked at", ownerWallet?.linked_at ? new Date(ownerWallet.linked_at).toLocaleString() : "(none)"],
+    ["Deposit wallet", depositWallet?.wallet_address ?? "(none)"],
+    ["Deposit deployed", status.depositWalletDeployed ? "yes" : "no"],
+    ["Deposit approved", status.depositWalletApproved ? "yes" : "no"],
+    ["Deposit ready", status.depositWalletReady ? "yes" : "no"],
+    ["Relayer configured", status.relayerConfigured ? "yes" : "no"]
+  ]);
+}
+function displayWalletBalances(balances) {
+  heading("Wallet Funds");
+  table([
+    ["Wallet", balances.walletAddress],
+    ["Chain", `${NETWORK_NAME} (${balances.chainId})`],
+    ["Available pUSD", displayAmount(balances.available)],
+    ["USDC.e", displayAmount(balances.assets.usdcE)],
+    [displayAssetSymbol(balances.assets.matic), displayAmount(balances.assets.matic)],
+    ["Updated", new Date(balances.updatedAt).toLocaleString()]
+  ]);
+}
+function displayDepositInstructions(instructions) {
+  heading("Deposit");
+  table([
+    ["Public deposit address", instructions.publicDepositAddress],
+    ["Network", `${instructions.network} (${instructions.chainId})`]
+  ]);
+  process.stdout.write("\n");
+  table(
+    instructions.assets.map((asset) => [
+      displayAssetSymbol(asset),
+      tokenAddress(asset),
+      displayAmount(asset)
+    ]),
+    ["Asset", "Token contract", "Current balance"]
+  );
+  process.stdout.write("\n");
+  warn(instructions.warning);
+}
+function displayBridgeDeposit(result) {
+  const bridgeAddresses = result.bridge?.address ?? {};
+  const rows = Object.entries(bridgeAddresses).filter(([, value]) => typeof value === "string" && value.length > 0).map(([network, value]) => [network.toUpperCase(), value]);
+  if (rows.length === 0) return;
+  process.stdout.write("\n");
+  table(rows, ["Bridge network", "Bridge deposit address"]);
+  if (result.bridge?.note) {
+    process.stdout.write("\n" + dim(`  ${result.bridge.note}
+`));
+  }
+  for (const warning of result.bridge?.warnings ?? []) {
+    if (warning.message) warn(warning.message);
+  }
+}
+function displayWithdrawIntent(intent) {
+  heading("Withdraw");
+  table([
+    ["Intent", intent.id],
+    ["Status", intent.status],
+    ["Wallet", intent.walletAddress],
+    ["Amount", `${intent.amount} pUSD`],
+    ["Recipient", intent.recipientAddress],
+    ["Destination", `chain ${intent.toChainId} \xB7 ${intent.toTokenAddress}`],
+    ["Bridge address", intent.bridgeAddresses.evm ?? "(none)"],
+    ["Signing URL", intent.signingUrl]
+  ]);
+  const quote = intent.quote ?? {};
+  if (quote.estOutputUsd !== void 0 || quote.estCheckoutTimeMs !== void 0) {
+    process.stdout.write("\n");
+    table([
+      ["Estimated output", quote.estOutputUsd !== void 0 ? currency(Number(quote.estOutputUsd)) : "-"],
+      ["Estimated checkout", quote.estCheckoutTimeMs !== void 0 ? `${Math.round(Number(quote.estCheckoutTimeMs) / 1e3)}s` : "-"]
+    ]);
+  }
+}
+function openBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = spawn(command, args, { detached: true, stdio: "ignore" });
+  child.unref();
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function pollWithdrawalIntent(client, id, opts) {
+  const started = Date.now();
+  let lastStatus = "";
+  while (Date.now() - started <= opts.timeoutSeconds * 1e3) {
+    const result = await client.get(
+      `/api/wallet/withdraw/intents/${encodeURIComponent(id)}`
+    );
+    const intent = result.intent;
+    if (!opts.jsonMode && intent.status !== lastStatus) {
+      process.stderr.write(dim(`  Withdrawal status: ${intent.status}
+`));
+      lastStatus = intent.status;
+    }
+    if (TERMINAL_WITHDRAWAL_STATUSES.has(intent.status)) return intent;
+    await sleep(opts.intervalSeconds * 1e3);
+  }
+  throw new Error(`Timed out waiting for withdrawal intent ${id}`);
+}
+function registerWalletCommands(program2) {
+  const wallet = program2.command("wallet").description("Inspect linked wallet funds and funding instructions");
+  wallet.command("status").description("Show linked owner and Polymarket deposit wallet status").action(async () => {
+    const globalOpts = program2.opts();
+    const client = new ApiClient(globalOpts);
+    requireAuth7(client);
+    const status = await client.get("/api/wallet/status");
+    if (globalOpts.json) {
+      json(status);
+      return;
+    }
+    displayWalletStatus(status);
+  });
+  wallet.command("balances").alias("funds").description("Show available wallet funds").action(async () => {
+    const globalOpts = program2.opts();
+    const client = new ApiClient(globalOpts);
+    requireAuth7(client);
+    const balances = await client.get("/api/wallet/balances");
+    if (globalOpts.json) {
+      json(balances);
+      return;
+    }
+    displayWalletBalances(balances);
+  });
+  wallet.command("deposit").description("Show deposit address and supported Polygon assets").option("--asset <asset>", "pUSD | USDC.e | POL").option("--bridge", "Also request Polymarket Bridge deposit addresses").action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = new ApiClient(globalOpts);
+    requireAuth7(client);
+    const asset = normalizeWalletAsset(opts.asset);
+    const result = await client.post("/api/wallet/deposit", {
+      bridge: Boolean(opts.bridge)
+    });
+    const balances = {
+      walletAddress: result.direct.walletAddress,
+      chainId: result.direct.chainId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      available: result.direct.assets.pUsd,
+      assets: result.direct.assets
+    };
+    const instructions = buildDepositInstructions(balances, asset);
+    if (globalOpts.json) {
+      json({ ...result, instructions });
+      return;
+    }
+    displayDepositInstructions(instructions);
+    displayBridgeDeposit(result);
+  });
+  wallet.command("withdraw").description("Create a browser-signed withdrawal intent and poll for completion").requiredOption("--to <address>", "Recipient EVM wallet address", parseWalletAddress).requiredOption("--amount <amount>", "Amount to withdraw", parsePositiveNumber2).option("--asset <asset>", "Source asset; currently only pUSD is supported", "pUSD").option("--to-chain-id <id>", "Destination chain id", "137").option("--to-token-address <address>", "Destination token address", parseWalletAddress, POLYGON_NATIVE_USDC).option("--no-open", "Do not open the browser signing URL").option("--no-wait", "Do not poll for completion after creating the intent").option("--poll-interval <seconds>", "Polling interval in seconds", parsePositiveNumber2, 5).option("--timeout <seconds>", "Maximum seconds to wait for completion", parsePositiveNumber2, 600).action(async (opts) => {
+    const globalOpts = program2.opts();
+    const client = new ApiClient(globalOpts);
+    requireAuth7(client);
+    const created = await client.post(
+      "/api/wallet/withdraw/intents",
+      buildWithdrawRequestPayload(opts)
+    );
+    let intent = created.intent;
+    if (opts.open !== false) {
+      openBrowser(intent.signingUrl);
+    }
+    if (opts.wait !== false) {
+      intent = await pollWithdrawalIntent(client, intent.id, {
+        timeoutSeconds: opts.timeout ?? 600,
+        intervalSeconds: opts.pollInterval ?? 5,
+        jsonMode: Boolean(globalOpts.json)
+      });
+    }
+    if (globalOpts.json) {
+      json(intent);
+      return;
+    } else {
+      displayWithdrawIntent(intent);
+    }
+  });
+}
+
 // src/index.ts
-var program = new Command2();
-program.name("hl").description("Hedge Layer CLI \u2014 prediction market intelligence from the terminal").version("1.5.0").option("--json", "Output as JSON (machine-readable)").option("--api-url <url>", "Override API base URL").option("--token <token>", "Override stored API token").option("--verbose", "Show HTTP request details").option("--no-color", "Disable colored output");
+var program = new Command4();
+program.name("hl").description("Hedge Layer CLI \u2014 prediction market intelligence from the terminal").version("1.7.0").option("--json", "Output as JSON (machine-readable)").option("--api-url <url>", "Override API base URL").option("--token <token>", "Override stored API token").option("--verbose", "Show HTTP request details").option("--no-color", "Disable colored output");
 registerAuthCommands(program);
 registerBriefCommands(program);
 registerProfileCommand(program);
 registerResearchCommands(program);
 registerFeedCommand(program);
+registerWalletCommands(program);
+registerLpCommands(program);
 registerAllocatorCommands(program);
 program.hook("preAction", (_thisCommand, actionCommand) => {
   const opts = program.opts();