@hedge-layer/cli 1.6.0 → 1.8.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 Command5 } from "commander";
 
 // src/commands/auth.ts
 import readline from "readline/promises";
@@ -838,11 +838,12 @@ function registerResearchCommands(program2) {
     });
     table(rows, ["ID", "Status", "Brief", "Markets", "Created"]);
   });
-  research.command("show <id>").description("Show research session details").action(async (id) => {
+  research.command("show <id>").description("Show research session details (accepts the short ID shown by `hl research list`)").action(async (id) => {
     const globalOpts = program2.opts();
     const client = new ApiClient(globalOpts);
     requireAuth3(client);
-    const assessment = await client.get(`/api/assessments/${id}`);
+    const fullId = await resolveOrExit(client, id);
+    const assessment = await client.get(`/api/assessments/${fullId}`);
     if (globalOpts.json) {
       json(assessment);
       return;
@@ -857,14 +858,53 @@ function registerResearchCommands(program2) {
       displayMarketBrief(assessment.market_brief, globalOpts);
     }
   });
-  research.command("delete <id>").description("Delete a research session").action(async (id) => {
+  research.command("delete <id>").description("Delete a research session (accepts the short ID shown by `hl research list`)").action(async (id) => {
     const globalOpts = program2.opts();
     const client = new ApiClient(globalOpts);
     requireAuth3(client);
-    await client.delete(`/api/assessments/${id}`);
+    const fullId = await resolveOrExit(client, id);
+    await client.delete(`/api/assessments/${fullId}`);
     success("Research session deleted.");
   });
 }
+var FULL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function matchAssessmentId(idOrPrefix, ids) {
+  const needle = idOrPrefix.trim().toLowerCase();
+  if (!needle) {
+    throw new Error("No research session ID provided.");
+  }
+  const exact = ids.find((id) => id.toLowerCase() === needle);
+  if (exact) return exact;
+  const matches = ids.filter((id) => id.toLowerCase().startsWith(needle));
+  if (matches.length === 1) return matches[0];
+  if (matches.length === 0) {
+    throw new Error(
+      `No research session found matching "${idOrPrefix}". Run \`hl research list\` to see available sessions.`
+    );
+  }
+  const shortIds = matches.map((id) => id.slice(0, 8)).join(", ");
+  throw new Error(
+    `"${idOrPrefix}" matches ${matches.length} research sessions (${shortIds}). Use a longer ID prefix to disambiguate.`
+  );
+}
+async function resolveAssessmentId(client, idOrPrefix) {
+  const trimmed = idOrPrefix.trim();
+  if (FULL_UUID.test(trimmed)) return trimmed;
+  const data = await client.get("/api/assessments", { list: "true" });
+  return matchAssessmentId(
+    trimmed,
+    data.assessments.map((a) => a.id)
+  );
+}
+async function resolveOrExit(client, idOrPrefix) {
+  try {
+    return await resolveAssessmentId(client, idOrPrefix);
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("API error")) throw e;
+    error(e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
+}
 function requireAuth3(client) {
   if (!client.isAuthenticated) {
     error("Not logged in. Run " + bold("hl auth login") + " first.");
@@ -1333,15 +1373,764 @@ 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/commands/signal.ts
+import { InvalidArgumentError as InvalidArgumentError4 } from "commander";
+import { readFile as readFile2 } from "fs/promises";
+
+// src/signal-display.ts
+import chalk8 from "chalk";
+function pctFromSignalValue(value) {
+  if (value === null || value === void 0 || Number.isNaN(value)) return null;
+  return Math.abs(value) <= 1 ? value * 100 : value;
+}
+function formatProbability(value) {
+  const pct = pctFromSignalValue(value);
+  return pct === null ? "n/a" : `${pct.toFixed(1)}%`;
+}
+function formatGap(value) {
+  if (value === null || value === void 0 || Number.isNaN(value)) return "n/a";
+  const points = Math.abs(value) <= 1 ? value * 100 : value;
+  const formatted = `${points >= 0 ? "+" : ""}${points.toFixed(1)}pp`;
+  if (points > 0) return chalk8.green(formatted);
+  if (points < 0) return chalk8.red(formatted);
+  return chalk8.dim(formatted);
+}
+function formatStrength(value) {
+  if (value === "strong") return chalk8.green("strong");
+  if (value === "weak") return chalk8.yellow("weak");
+  return value ? chalk8.dim(value) : "n/a";
+}
+function analysisItems(result) {
+  if (!result) return [];
+  if (result.analysis) return [result];
+  return result.analyses ?? [];
+}
+function titleFor(analysis) {
+  return analysis.market_name || analysis.market_slug || "market";
+}
+function displaySignalAnalysis(response, globalOpts) {
+  if (globalOpts.json) {
+    json(response);
+    return;
+  }
+  if (response.error) {
+    error(response.error);
+    return;
+  }
+  const result = response.result;
+  if (result?.error) {
+    error(result.error);
+    return;
+  }
+  const items = analysisItems(result);
+  if (items.length === 0) {
+    warn("No signal analysis returned.");
+    return;
+  }
+  heading(
+    items.length === 1 ? "Signal Analysis" : `Signal Analysis \u2014 ${items.length} markets`
+  );
+  const rows = items.map((item) => {
+    const analysis = item.analysis ?? {};
+    return [
+      truncate(titleFor(analysis), 44),
+      formatProbability(analysis.current_yes_prob),
+      formatProbability(analysis.predicted_prob),
+      formatGap(analysis.probability_gap),
+      formatStrength(analysis.signal_strength),
+      analysis.confidence ?? "n/a"
+    ];
+  });
+  table(rows, ["Market", "Market YES", "Agent YES", "Gap", "Signal", "Conf"]);
+  for (const item of items.slice(0, 3)) {
+    const analysis = item.analysis;
+    if (!analysis) continue;
+    process.stdout.write("\n  " + chalk8.bold(truncate(titleFor(analysis), 76)) + "\n");
+    if (analysis.market_link) {
+      process.stdout.write("  " + chalk8.dim("Polymarket: ") + analysis.market_link + "\n");
+    }
+    if (analysis.key_factors && analysis.key_factors.length > 0) {
+      process.stdout.write("  " + chalk8.dim("Key factors: ") + analysis.key_factors.slice(0, 4).join("; ") + "\n");
+    }
+    if (analysis.research_findings) {
+      process.stdout.write(
+        "  " + chalk8.dim("Research: ") + truncate(analysis.research_findings, 180) + "\n"
+      );
+    }
+  }
+  if (items.length > 3) {
+    process.stdout.write(chalk8.dim(`
+  ... and ${items.length - 3} more
+`));
+  }
+  if (result?.strong_signal_count !== void 0) {
+    process.stdout.write(
+      chalk8.dim(`
+  Strong signals: ${result.strong_signal_count}
+`)
+    );
+  }
+}
+
+// src/commands/signal.ts
+function requireAuth8(client) {
+  if (!client.isAuthenticated) {
+    error("Not authenticated. Run `hl auth login` first.");
+    process.exit(1);
+  }
+}
+function collect(value, previous = []) {
+  return [...previous, value];
+}
+function parseProbability(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0 || n > 100) {
+    throw new InvalidArgumentError4("Expected a probability between 0 and 100");
+  }
+  return n;
+}
+async function readStdin2() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function readMarketPayload(path) {
+  if (!path) return {};
+  const raw = path === "-" ? await readStdin2() : await readFile2(path, "utf8");
+  const parsed = JSON.parse(raw);
+  if (Array.isArray(parsed)) {
+    return { markets: parsed };
+  }
+  if (parsed && typeof parsed === "object" && Array.isArray(parsed.markets)) {
+    return { markets: parsed.markets };
+  }
+  if (parsed && typeof parsed === "object" && parsed.market) {
+    return { market: parsed.market };
+  }
+  if (parsed && typeof parsed === "object") {
+    return { market: parsed };
+  }
+  throw new Error("Market JSON must be an object, an array, or { market | markets }");
+}
+function inlineMarketFromOptions(opts) {
+  const market = {};
+  if (opts.question) market.question = opts.question;
+  if (opts.description) market.description = opts.description;
+  if (opts.yesProb !== void 0) market.yesPrice = opts.yesProb;
+  if (opts.noProb !== void 0) market.noPrice = opts.noProb;
+  if (opts.slug) market.slug = opts.slug;
+  if (opts.link) market.link = opts.link;
+  return Object.keys(market).length > 0 ? market : void 0;
+}
+async function buildSignalPayload(positionalUrl, opts) {
+  const urls = [positionalUrl, ...opts.url ?? []].filter(
+    (value) => Boolean(value)
+  );
+  const filePayload = await readMarketPayload(opts.market);
+  const inlineMarket = inlineMarketFromOptions(opts);
+  const hasMarketInput = Boolean(filePayload.market || filePayload.markets || inlineMarket);
+  if (urls.length > 0 && hasMarketInput) {
+    throw new Error("Use either URL input or market JSON/options, not both.");
+  }
+  if (filePayload.market && inlineMarket) {
+    throw new Error("Use either --market or inline market options, not both.");
+  }
+  if (filePayload.markets && inlineMarket) {
+    throw new Error("Use either --market or inline market options, not both.");
+  }
+  if (urls.length === 0 && !hasMarketInput) {
+    throw new Error("Provide a Polymarket URL or a market payload.");
+  }
+  const payload = urls.length === 1 ? { url: urls[0] } : urls.length > 1 ? { urls } : filePayload.market ? { market: filePayload.market } : filePayload.markets ? { markets: filePayload.markets } : { market: inlineMarket };
+  if (opts.context) {
+    payload.previous_analysis_context = opts.context;
+  }
+  return payload;
+}
+async function runSignalAnalysis(client, payload) {
+  return client.post("/api/signal/analyze", payload);
+}
+function registerSignalCommands(program2) {
+  const signal = program2.command("signal").description("Analyze Polymarket probability gaps with the signal agent");
+  signal.command("analyze").description("Estimate true YES probability and compare it with market pricing").argument("[url]", "Polymarket market/event URL to analyze").option("--url <url>", "Additional Polymarket URL; repeat for multiple markets", collect, []).option("--market <file>", "Inline market JSON object/array; use '-' to read stdin").option("--context <text>", "Prior search notes or analysis context for the agent").option("--question <text>", "Inline market question when not using a URL").option("--description <text>", "Inline market description or resolution criteria").option("--yes-prob <prob>", "Current YES probability or price, e.g. 0.52 or 52", parseProbability).option("--no-prob <prob>", "Current NO probability or price, e.g. 0.48 or 48", parseProbability).option("--slug <slug>", "Inline market slug").option("--link <url>", "Inline market link").action(async (url, o) => {
+    const globalOpts = program2.opts();
+    const client = new ApiClient(globalOpts);
+    requireAuth8(client);
+    let payload;
+    try {
+      payload = await buildSignalPayload(url, o);
+    } catch (e) {
+      error(e instanceof Error ? e.message : String(e));
+      process.exit(1);
+    }
+    if (!globalOpts.json) {
+      process.stderr.write(dim("  Running signal analysis...\n"));
+    }
+    const result = await runSignalAnalysis(client, payload);
+    displaySignalAnalysis(result, globalOpts);
+  });
+}
+
 // src/index.ts
-var program = new Command2();
-program.name("hl").description("Hedge Layer CLI \u2014 prediction market intelligence from the terminal").version("1.6.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 Command5();
+program.name("hl").description("Hedge Layer CLI \u2014 prediction market intelligence from the terminal").version("1.8.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);
+registerSignalCommands(program);
 program.hook("preAction", (_thisCommand, actionCommand) => {
   const opts = program.opts();
   if (opts.color === false) {