@hedge-layer/cli 2.0.0 → 2.2.0

package/README.md

@@ -86,7 +86,8 @@ The lightweight manual loop is:
 
 ```bash
 hl --json feed lp-opportunity --limit 15 > markets.json
-hl lp allocator --markets markets.json
+hl-trader pnl --json > pnl.json   # optional: wallet PnL + live inventory
+hl lp allocator --markets markets.json --pnl pnl.json --allocations pnl.json
 hl-trader buy ...
 ```
 
@@ -95,6 +96,11 @@ allocator agent. Allocator output shows target capital, quote regime, failed
 safety checks, and split spread/reward economics. Trade execution stays outside
 the `hl` allocator command.
 
+`--allocations` tells the allocator what you already hold (enabling HOLD,
+REDUCE, and EXIT decisions), and `--pnl` feeds per-market PnL into its caution
+overlay so borderline allocations on losing markets are downgraded to WATCH or
+HOLD. Both flags accept the `hl-trader pnl --json` output file directly.
+
 Wallet commands are available under `hl wallet`:
 
 ```bash

package/dist/index.mjs

@@ -980,6 +980,7 @@ function displayMarketBrief(brief, globalOpts) {
 }
 
 // src/commands/feed.ts
+import { writeFile } from "fs/promises";
 function requireAuth4(client) {
   if (!client.isAuthenticated) {
     error("Not authenticated. Run `hl auth login` first.");
@@ -1024,8 +1025,136 @@ function feedQueryParams(opts) {
   add("limit", opts.limit);
   return Object.fromEntries(entries);
 }
+var ENSEMBLE_SOURCES = [
+  { name: "liquid-core", params: { sortBy: "liquidity", preset: "liquidity-focused" } },
+  { name: "active-volume", params: { sortBy: "volume", preset: "volume-hunter" } },
+  { name: "movers", params: { sortBy: "movement", preset: "price-movers" } },
+  { name: "new-markets", params: { sortBy: "recency", preset: "new-markets" } },
+  { name: "uncertainty", params: { sortBy: "extremity" } },
+  { name: "lp-quality", params: { profile: "liquidity-provider", sortBy: "lpExpectedReturn" } }
+];
+var EXTREME_PROBABILITY_LOW = 0.07;
+var EXTREME_PROBABILITY_HIGH = 0.93;
+var EXTREME_PROBABILITY_MAX_PENALTY = 15;
+var HORIZON_PEAK_DAYS = 365;
+var HORIZON_LONG_TERM_DECAY_PER_YEAR = 4;
+var HORIZON_LONG_TERM_FLOOR = 2;
+var ENSEMBLE_SOURCE_SCORE_PER_SOURCE = 2;
+var ENSEMBLE_SOURCE_SCORE_MAX = 8;
+var ENSEMBLE_MAX_CANDIDATES_PER_EVENT = 2;
+var ENSEMBLE_MAX_SINGLE_SOURCE_CANDIDATES = 5;
+function num(value) {
+  return Number.isFinite(value) ? Number(value) : 0;
+}
+function extremeProbabilityPenalty(candidate) {
+  const probability = Number.isFinite(candidate.probability) ? Number(candidate.probability) : candidate.yesPrice;
+  const boundedProbability = Math.max(0, Math.min(1, probability));
+  if (boundedProbability < EXTREME_PROBABILITY_LOW) {
+    return (EXTREME_PROBABILITY_LOW - boundedProbability) / EXTREME_PROBABILITY_LOW * EXTREME_PROBABILITY_MAX_PENALTY;
+  }
+  if (boundedProbability > EXTREME_PROBABILITY_HIGH) {
+    return (boundedProbability - EXTREME_PROBABILITY_HIGH) / (1 - EXTREME_PROBABILITY_HIGH) * EXTREME_PROBABILITY_MAX_PENALTY;
+  }
+  return 0;
+}
+function horizonScore(days) {
+  if (days === null) return 2;
+  if (days < 3) return 0;
+  if (days <= HORIZON_PEAK_DAYS) {
+    return Math.log1p(days) / Math.log1p(HORIZON_PEAK_DAYS) * 10;
+  }
+  const yearsPastPeak = (days - HORIZON_PEAK_DAYS) / HORIZON_PEAK_DAYS;
+  return Math.max(HORIZON_LONG_TERM_FLOOR, 10 - yearsPastPeak * HORIZON_LONG_TERM_DECAY_PER_YEAR);
+}
+function scoreCandidate(candidate, sourceCount) {
+  const liquidityScore = Math.min(25, Math.log1p(Math.max(0, candidate.liquidity)) / Math.log1p(1e6) * 25);
+  const volumeScore = Math.min(25, Math.log1p(Math.max(0, candidate.volume24h)) / Math.log1p(1e6) * 25);
+  const spreadScore = Math.max(0, Math.min(15, (0.12 - Math.max(0, candidate.spread)) / 0.12 * 15));
+  const movementPenalty = Math.min(20, Math.abs(candidate.oneDayPriceChange) * 100);
+  const probabilityPenalty = extremeProbabilityPenalty(candidate);
+  const days = candidate.daysToEnd ?? null;
+  const horizon = horizonScore(days);
+  const rewardScore = Math.max(
+    0,
+    Math.min(20, num(candidate.components?.rewardYield) * 0.1 + Math.max(0, num(candidate.lpExpectedReturnDailyPct)) * 50)
+  );
+  const sourceScore = Math.min(ENSEMBLE_SOURCE_SCORE_MAX, sourceCount * ENSEMBLE_SOURCE_SCORE_PER_SOURCE);
+  return Math.round(
+    (liquidityScore + volumeScore + spreadScore + horizon + rewardScore + sourceScore - movementPenalty - probabilityPenalty) * 10
+  ) / 10;
+}
+function diversifyCandidates(candidates, limit) {
+  const eventCounts = /* @__PURE__ */ new Map();
+  const singleSourceCounts = /* @__PURE__ */ new Map();
+  const diversified = [];
+  for (const candidate of candidates) {
+    const eventKey = candidate.eventSlug || candidate.slug;
+    const eventCount = eventCounts.get(eventKey) ?? 0;
+    if (eventCount >= ENSEMBLE_MAX_CANDIDATES_PER_EVENT) continue;
+    const singleSource = candidate.sourceProfiles.length === 1 ? candidate.sourceProfiles[0] : null;
+    if (singleSource !== null) {
+      const sourceCount = singleSourceCounts.get(singleSource) ?? 0;
+      if (sourceCount >= ENSEMBLE_MAX_SINGLE_SOURCE_CANDIDATES) continue;
+      singleSourceCounts.set(singleSource, sourceCount + 1);
+    }
+    eventCounts.set(eventKey, eventCount + 1);
+    diversified.push(candidate);
+    if (diversified.length >= limit) break;
+  }
+  return diversified;
+}
+function buildFeedEnsemble(sourceResults, limit, outputPath = "candidates.json", generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const bySlug = /* @__PURE__ */ new Map();
+  let totalRawMarkets = 0;
+  for (const { source, result } of sourceResults) {
+    for (const market of result.markets ?? []) {
+      totalRawMarkets++;
+      const existing = bySlug.get(market.slug);
+      if (!existing) {
+        bySlug.set(market.slug, {
+          ...market,
+          ensembleScore: 0,
+          sourceProfiles: [source],
+          sourceRanks: { [source]: market.rank }
+        });
+        continue;
+      }
+      existing.sourceProfiles.push(source);
+      existing.sourceRanks[source] = market.rank;
+      if (market.score > existing.score) existing.score = market.score;
+      existing.volume24h = Math.max(existing.volume24h, market.volume24h);
+      existing.liquidity = Math.max(existing.liquidity, market.liquidity);
+      existing.rewardsDailyRate = Math.max(existing.rewardsDailyRate, market.rewardsDailyRate);
+      existing.lpExpectedReturnDailyPct = Math.max(
+        num(existing.lpExpectedReturnDailyPct),
+        num(market.lpExpectedReturnDailyPct)
+      );
+      existing.lpRiskFlags = [.../* @__PURE__ */ new Set([...existing.lpRiskFlags ?? [], ...market.lpRiskFlags ?? []])];
+    }
+  }
+  const candidates = [...bySlug.values()].map((candidate) => ({
+    ...candidate,
+    sourceProfiles: [...new Set(candidate.sourceProfiles)],
+    ensembleScore: scoreCandidate(candidate, new Set(candidate.sourceProfiles).size)
+  })).sort((a, b) => b.ensembleScore - a.ensembleScore || b.score - a.score);
+  const diversifiedCandidates = diversifyCandidates(candidates, limit);
+  return {
+    generatedAt,
+    outputPath,
+    totalSources: sourceResults.length,
+    totalRawMarkets,
+    totalCandidates: bySlug.size,
+    marketsReturned: diversifiedCandidates.length,
+    candidates: diversifiedCandidates
+  };
+}
+function parseLimit(value, fallback) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(1, Math.min(100, parsed));
+}
 function registerFeedCommand(program2) {
-  program2.command("feed").description(
+  const feed = program2.command("feed").description(
     "Rank active Polymarket markets (same engine as chat getFeed / GET /api/feed). Use --profile for curated screens."
   ).argument(
     "[screening]",
@@ -1033,7 +1162,50 @@ function registerFeedCommand(program2) {
   ).option(
     "--profile <name>",
     `Screening defaults: ${PROFILE_CHOICES.join(", ")} \u2014 explicit flags override`
-  ).option("--sort-by <key>", "score | volume | liquidity | movement | spread | recency | extremity | rewards | rewardYield | lpExpectedReturn | horizon").option("--preset <name>", "Attention weight preset (default, volume-hunter, lp-opportunity, \u2026)").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>", "Min calendar days until resolution").option("--max-days-to-end <n>", "Max calendar days until resolution").option("--max-market-age-hours <n>", 'With liquid-new-or-long: max age (hours) for the "new" branch').option("--liquid-profile <mode>", "new-or-long (used by liquid-new-or-long screen)").option("--limit <n>", "Max markets to return (1\u2013100, default 15)", "15").action(async (screening, o) => {
+  ).option("--sort-by <key>", "score | volume | liquidity | movement | spread | recency | extremity | rewards | rewardYield | lpExpectedReturn | horizon").option("--preset <name>", "Attention weight preset (default, volume-hunter, lp-opportunity, \u2026)").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>", "Min calendar days until resolution").option("--max-days-to-end <n>", "Max calendar days until resolution").option("--max-market-age-hours <n>", 'With liquid-new-or-long: max age (hours) for the "new" branch').option("--liquid-profile <mode>", "new-or-long (used by liquid-new-or-long screen)").option("--limit <n>", "Max markets to return (1\u2013100, default 15)", "15");
+  feed.command("ensemble").description("Run multiple feed screens, merge by slug, and write ranked candidates JSON").option("--limit <n>", "Max candidates to return/write (1-100, default 25)", "25").option("--output <file>", "Output JSON path", "candidates.json").action(async (o) => {
+    const globalOpts = program2.opts();
+    const client = new ApiClient(globalOpts);
+    requireAuth4(client);
+    const perSourceLimit = "100";
+    const sourceResults = [];
+    try {
+      for (const source of ENSEMBLE_SOURCES) {
+        const result = await client.get("/api/feed", {
+          ...source.params,
+          limit: perSourceLimit
+        });
+        if (result.error) {
+          throw new Error(result.error);
+        }
+        sourceResults.push({ source: source.name, result });
+      }
+      const outputPath = o.output ?? "candidates.json";
+      const ensemble = buildFeedEnsemble(sourceResults, parseLimit(o.limit, 25), outputPath);
+      await writeFile(outputPath, JSON.stringify(ensemble, null, 2) + "\n", "utf8");
+      if (globalOpts.json) {
+        json(ensemble);
+        return;
+      }
+      heading(`Feed Ensemble \u2014 ${ensemble.marketsReturned} candidates`);
+      table(
+        ensemble.candidates.slice(0, 15).map((m) => [
+          String(Math.round(m.ensembleScore)),
+          truncate(m.question, 48),
+          `${Math.round(m.yesPrice * 100)}%`,
+          compactCurrency(m.volume24h),
+          compactCurrency(m.liquidity),
+          m.sourceProfiles.join(",")
+        ]),
+        ["Score", "Market", "YES", "24h Vol", "Liq", "Sources"]
+      );
+      success(`Wrote ${outputPath}`);
+    } catch (e) {
+      error(e instanceof Error ? e.message : String(e));
+      process.exit(1);
+    }
+  });
+  feed.action(async (screening, o) => {
     const globalOpts = program2.opts();
     let profile;
     try {
@@ -1075,7 +1247,7 @@ function registerFeedCommand(program2) {
 
 // src/commands/lp.ts
 import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
-import { writeFile } from "fs/promises";
+import { writeFile as writeFile2 } from "fs/promises";
 
 // src/allocator-display.ts
 import chalk5 from "chalk";
@@ -1095,7 +1267,7 @@ function actionColor(action) {
       return action;
   }
 }
-function num(value, fallback = 0) {
+function num2(value, fallback = 0) {
   const n = Number(value);
   return Number.isFinite(n) ? n : fallback;
 }
@@ -1110,8 +1282,8 @@ function displayAllocatorCycleResult(result, globalOpts) {
   heading(`Allocator Cycle \u2014 ${dryRun}`);
   process.stdout.write(
     chalk5.dim(
-      `  ${num(result.total_markets, decisions.length)} markets \xB7 ${currency(
-        num(summary.target_capital)
+      `  ${num2(result.total_markets, decisions.length)} markets \xB7 ${currency(
+        num2(summary.target_capital)
       )} target capital
 
 `
@@ -1123,14 +1295,14 @@ function displayAllocatorCycleResult(result, globalOpts) {
   }
   const rows = decisions.map((d) => {
     const action = String(d.action ?? "UNKNOWN");
-    const score = num(d.score?.score);
-    const expected = num(d.score?.expected_return_daily_pct);
+    const score = num2(d.score?.score);
+    const expected = num2(d.score?.expected_return_daily_pct);
     const failedChecks = Array.isArray(d.safety_checks) ? d.safety_checks.filter((check) => check.passed === false).length : 0;
     return [
       truncate(String(d.question ?? d.market_slug ?? "\u2014"), 42),
       actionColor(action),
-      currency(num(d.target_capital)),
-      signedCurrency(num(d.capital_delta)),
+      currency(num2(d.target_capital)),
+      signedCurrency(num2(d.capital_delta)),
       `${expected.toFixed(3)}%`,
       regimeLabel(String(d.quote_regime ?? "\u2014")),
       String(Math.round(score)),
@@ -1159,7 +1331,7 @@ function displayAllocatorCycleResult(result, globalOpts) {
     const economics = decision.economics ?? {};
     if (economics.realized_spread_pnl !== void 0 || economics.reward_income !== void 0 || economics.net_realized_pnl !== void 0) {
       process.stdout.write(
-        "    " + chalk5.dim("Economics: ") + `spread ${signedCurrency(num(economics.realized_spread_pnl))}, rewards ${signedCurrency(num(economics.reward_income))}, net ${signedCurrency(num(economics.net_realized_pnl))}
+        "    " + chalk5.dim("Economics: ") + `spread ${signedCurrency(num2(economics.realized_spread_pnl))}, rewards ${signedCurrency(num2(economics.reward_income))}, net ${signedCurrency(num2(economics.net_realized_pnl))}
 `
       );
     }
@@ -1199,26 +1371,49 @@ function parsePositiveNumber(value) {
   }
   return n;
 }
+function parseAllocationsInput(parsed) {
+  const rows = extractArray(parsed, "allocations");
+  if (!rows) {
+    throw new Error("Allocations JSON must be an array or { allocations: [...] }");
+  }
+  return rows;
+}
+function parsePnlContextInput(parsed) {
+  const rows = extractArray(parsed, "pnl_context");
+  if (!rows) {
+    throw new Error("PnL JSON must be an array or { pnl_context: [...] }");
+  }
+  return rows;
+}
 async function readAllocations(path) {
   if (!path) return [];
-  const raw = path === "-" ? await readStdin() : await readFile(path, "utf8");
-  const parsed = JSON.parse(raw);
-  if (!Array.isArray(parsed)) {
-    throw new Error("Allocations JSON must be an array");
-  }
-  return parsed;
+  return parseAllocationsInput(await readJsonInput(path));
+}
+async function readPnlContext(path) {
+  if (!path) return [];
+  return parsePnlContextInput(await readJsonInput(path));
 }
 async function readMarketPayload(path) {
   if (!path) return void 0;
-  const raw = path === "-" ? await readStdin() : await readFile(path, "utf8");
-  const parsed = JSON.parse(raw);
+  const parsed = await readJsonInput(path);
+  const rows = extractArray(parsed, "markets");
+  if (!rows) {
+    throw new Error("Markets JSON must be an array or { markets: [...] }");
+  }
+  return rows;
+}
+function extractArray(parsed, key) {
   if (Array.isArray(parsed)) {
     return parsed;
   }
-  if (parsed && typeof parsed === "object" && Array.isArray(parsed.markets)) {
-    return parsed.markets;
+  if (parsed && typeof parsed === "object" && Array.isArray(parsed[key])) {
+    return parsed[key];
   }
-  throw new Error("Markets JSON must be an array or { markets: [...] }");
+  return void 0;
+}
+async function readJsonInput(path) {
+  const raw = path === "-" ? await readStdin() : await readFile(path, "utf8");
+  return JSON.parse(raw);
 }
 async function readStdin() {
   const chunks = [];
@@ -1230,7 +1425,7 @@ async function readStdin() {
 
 // src/lp-display.ts
 import chalk6 from "chalk";
-function num2(value, fallback = 0) {
+function num3(value, fallback = 0) {
   const n = Number(value);
   return Number.isFinite(n) ? n : fallback;
 }
@@ -1242,7 +1437,7 @@ function signedCurrency2(value) {
 }
 function actionSummary(actions) {
   if (!actions) return "none";
-  return Object.entries(actions).filter(([, count]) => num2(count) > 0).map(([action, count]) => `${action}:${num2(count)}`).join(" ");
+  return Object.entries(actions).filter(([, count]) => num3(count) > 0).map(([action, count]) => `${action}:${num3(count)}`).join(" ");
 }
 function displayLpScanResult(result, globalOpts) {
   if (globalOpts.json) {
@@ -1271,10 +1466,10 @@ function displayLpScanResult(result, globalOpts) {
     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)}%`
+      String(Math.round(num3(market.score))),
+      compactCurrency(num3(market.liquidity)),
+      compactCurrency(num3(market.rewardsDailyRate)) + "/day",
+      `${num3(market.lpExpectedReturnDailyPct).toFixed(3)}%`
     ]),
     ["#", "Market", "Score", "Liq", "Rewards", "Exp/day"]
   );
@@ -1333,7 +1528,7 @@ function displayLpEvaluateResult(result, globalOpts) {
     result.lessons.slice(0, 8).map((lesson) => [
       truncate(String(lesson.market_slug ?? "portfolio"), 26),
       String(lesson.outcome ?? "flat"),
-      signedCurrency2(num2(lesson.net_pnl)),
+      signedCurrency2(num3(lesson.net_pnl)),
       truncate(String(lesson.lesson ?? "no lesson"), 64)
     ]),
     ["Market", "Outcome", "Net", "Lesson"]
@@ -1398,7 +1593,7 @@ function compact(payload) {
 }
 async function writeArtifact(path, data, jsonMode) {
   if (!path) return;
-  await writeFile(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+  await writeFile2(path, JSON.stringify(data, null, 2) + "\n", "utf8");
   if (!jsonMode) {
     process.stderr.write(dim(`  Saved artifact to ${path}
 `));
@@ -1443,7 +1638,7 @@ async function runAllocatorCycle(client, payload) {
 }
 function registerLpCommands(program2) {
   const lp = program2.command("lp").description("Run persisted liquidity-provider scan, recommendation, and evaluation workflows");
-  lp.command("allocator").description("Run the allocator agent on an explicit market list").requiredOption("--markets <file>", "Candidate market JSON array or { markets }; use '-' to read stdin").option("--allocations <file>", "Existing allocations JSON array; use '-' to read stdin").option("--total-holdings <usd>", "Total 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 allocator request", 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("--volatility-fill-spike-threshold <ratio>", "Fill-rate imbalance that switches quotes to defensive mode", parseNonNegative, 0.35).option("--event-no-quote-minutes-before <n>", "No-quote window before scheduled events", parseNonNegative, 60).option("--event-no-quote-minutes-after <n>", "No-quote window after scheduled events", parseNonNegative, 30).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("--paused", "Send strategy status paused instead of dry_run").action(async (opts) => {
+  lp.command("allocator").description("Run the allocator agent on an explicit market list").requiredOption("--markets <file>", "Candidate market JSON array or { markets }; use '-' to read stdin").option("--allocations <file>", "Existing allocations JSON array or { allocations }; use '-' to read stdin").option("--pnl <file>", "Per-market PnL context JSON array or { pnl_context } (hl-trader pnl --json output); use '-' to read stdin").option("--total-holdings <usd>", "Total 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 allocator request", 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("--volatility-fill-spike-threshold <ratio>", "Fill-rate imbalance that switches quotes to defensive mode", parseNonNegative, 0.35).option("--event-no-quote-minutes-before <n>", "No-quote window before scheduled events", parseNonNegative, 60).option("--event-no-quote-minutes-after <n>", "No-quote window after scheduled events", parseNonNegative, 30).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("--paused", "Send strategy status paused instead of dry_run").action(async (opts) => {
     const globalOpts = program2.opts();
     const client = new ApiClient(globalOpts);
     requireAuth5(client);
@@ -1453,10 +1648,16 @@ function registerLpCommands(program2) {
       error("Markets JSON must include at least one market.");
       process.exit(1);
     }
+    if (opts.allocations === "-" && opts.pnl === "-") {
+      error("Only one of --allocations and --pnl can read from stdin.");
+      process.exit(1);
+    }
+    const pnlContext = await readPnlContext(opts.pnl);
     const payload = {
       strategy: strategyFromAllocatorOptions(opts),
       markets,
-      allocations: await readAllocations(opts.allocations)
+      allocations: await readAllocations(opts.allocations),
+      ...pnlContext.length > 0 && { pnl_context: pnlContext }
     };
     if (!globalOpts.json) {
       process.stderr.write(
@@ -1971,7 +2172,7 @@ function registerSignalCommands(program2) {
 
 // src/index.ts
 var program = new Command4();
-program.name("hl").description("Hedge Layer CLI \u2014 prediction market intelligence from the terminal").version("2.0.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");
+program.name("hl").description("Hedge Layer CLI \u2014 prediction market intelligence from the terminal").version("2.2.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);