/* positions.jsx — Open Positions tab. Left: sortable table of active positions with expandable parser detail. Right: Latest Position Events rail (live ticking). */ function ActionCell({ action, confidence }) { return (
); } function ParserDetail({ event }) { if (!event) return null; return (

Raw Discord message

{event.raw}
channel {event.channel} msg {event.messageId} scraped {fmtTime(event.ts)}

Why Claude tagged this

{event.reasoning.summary.split(/("[^"]+")/).map((part, i) => part.startsWith('"') ? {part} : {part} )}

Extracted event JSON

{
`{
  `}"ticker"{`:     `}"{event.ticker}"{`,
  `}"action"{`:     `}"{event.action}"{`,
  `}"direction"{`:  `}"{event.direction}"{`,
  `}"contract"{`:   `}{event.contract ? `"${event.contract}"` : "null"}{`,
  `}"price"{`:      `}{event.price == null ? "null" : event.price.toFixed(2)}{`,
  `}"stop_loss"{`:  `}{event.stopLoss == null ? "null" : event.stopLoss}{`,
  `}"confidence"{`: `}"{event.confidence}"{`,
  `}"raw_note"{`:   `}"{event.raw.length > 60 ? event.raw.slice(0, 57) + "…" : event.raw}"{`,
  `}"matched"{`:    [`}{event.reasoning.matched.map((m, i) => [
            i ? ,  : null,
            "{m}"
          ])}{`]
}`}
model claude-haiku-4-5 latency {(280 + (event.id.charCodeAt(4)*7 % 220))}ms tokens {120 + (event.id.charCodeAt(5) % 80)}
); } // Every interaction with a trade (open / add / trim / close…), in order. // Position-level identity edit — corrects ticker / contract / strike / expiry / // type across EVERY event in the position in one write. Identity fields only: // price and action are per-event truths and stay on the single-event override. function PositionIdentityEdit({ position, onClose, onSaved }) { const p = position; const [ticker, setTicker] = useState(p.ticker || ""); const [kind, setKind] = useState(p.instrument === "shares" ? "shares" : "option"); const [optType, setOptType] = useState(p.optionType || "call"); const [strike, setStrike] = useState(p.strike != null ? String(p.strike) : ""); const [expiry, setExpiry] = useState(p.expiry || ""); const [busy, setBusy] = useState(false); const ids = (p.events || []).map(e => e.id).filter(Boolean); async function save() { const isOpt = kind === "option"; const body = { event_ids: ids, ticker: ticker.trim(), instrument: kind, contract: isOpt ? (buildContractText(strike, expiry, optType) || null) : null, strike: isOpt && strike.trim() !== "" ? Number(strike) : null, expiry: isOpt ? (expiry.trim() || null) : null, option_type: isOpt ? optType : null, }; setBusy(true); try { const r = await tapeSend(apiBase() + "/api/positions/identity", { method: "PATCH", headers: { "content-type": "application/json" }, body: JSON.stringify(body), }); const j = await r.json().catch(() => ({})); toast.success(`Updated ${j.updated ?? ids.length} event${(j.updated ?? ids.length) === 1 ? "" : "s"}`); if (onSaved) onSaved(j.events || []); onClose(); } catch (e) { toast.error("Couldn't update - " + e.message); } setBusy(false); } return (
!busy && onClose()}>
ev.stopPropagation()}>
{I("edit", { size: 16 })} Edit position
{p.analyst} · ${p.ticker} · applies to ALL {ids.length} event{ids.length === 1 ? "" : "s"}

Use this when the parser read the contract differently across messages. Editing those events one at a time splits the position instead of fixing it — this rewrites every event together. Prices and actions are untouched; correct those individually.

{kind === "option" && <> }
); } // "6/22 210C" from the parts — the same shape the bot's buildContract writes, so // a corrected position keys identically to a freshly-parsed one. function buildContractText(strike, expiry, optType) { const s = String(strike || "").trim(), e = String(expiry || "").trim(); if (!s && !e) return null; const t = optType === "put" ? "P" : "C"; return [e, s ? s + t : null].filter(Boolean).join(" "); } function TradeTimeline({ events, onEdit, position, onEditPosition }) { const ordered = [...events].sort((a, b) => a.ts - b.ts); // A position whose events disagree about strike / expiry / contract is really // TWO positions to the aggregator — the history splits and one half loses its // entry price. Fixing that one event at a time cannot work (each save re-splits // it differently), so the cascade edits every event in the position at once. const inconsistent = position && ( new Set(ordered.map(e => (e.strike == null ? "" : String(e.strike)))).size > 1 || new Set(ordered.map(e => e.optionType || "")).size > 1); return (
{onEditPosition && position && (
{inconsistent && ( contract mismatch across events )}
)} {ordered.map((e, i) => { // Staircase the lifecycle so the entry anchors at the left and the // follow-ups (add/trim/hold/cut/close) step in beneath it — easier to // read at a glance. Capped at 2 steps so a long timeline never marches // off the right edge. const level = Math.min(i, 2); // Exits (trim/cut/close) are always a fill ("@"); only an open holding // carries a mark ("-> n"). Tolerate older data that mis-filed an "@". const exitAction = ["close", "cut", "trim"].includes(e.action); const fill = e.price != null ? e.price : (exitAction ? e.currentPrice : null); const mark = (!exitAction && e.currentPrice != null) ? e.currentPrice : null; return (
); })}
); } // Mobile Open Positions — a compact accordion. Each row shows only ticker · // instrument · analyst · entry→now; tap a row to reveal the full metrics, last // alert, and the interaction timeline. (Desktop keeps the table.) function MobilePositionList({ rows, analysts, onOpenChart, onCalc, onManage, canManageRow, showParser, onEditEvent, canEditEvent, onEditPosition }) { const [open, setOpen] = useState(null); if (!rows.length) return ; return (
{rows.map(p => { const isOpen = open === p.key; const opt = isOption(p); const basis = p.avgPrice != null ? p.avgPrice : p.entryPrice; const pnl = (basis && p.markPrice != null) ? (p.markPrice - basis) / basis : null; const up = pnl != null && pnl >= 0; const lastEvent = p.events[p.events.length - 1]; const rcy = recencyBucket(p.updatedTs); return (
{isOpen && (
Action
Conf
{opt &&
Expiry
{p.expiry ? fmtExpiry(p.expiry) : "—"}
} {opt &&
Strike
{p.strike != null ? p.strike : "—"}
}
Stop
{p.stopLoss != null ? {fmtNum(p.stopLoss)} : "—"}
{window.LEDGER_UI ? "Last analyst update" : "Updated"}
{fmtTime(p.updatedTs, { short: true })}
{p.lastNote && (
Last alert

{p.lastNote}

)}
All interactions · {p.events.length}
{showParser && } {(onCalc || onOpenChart || onManage) && (
{onManage && (!canManageRow || canManageRow(p)) && } {onCalc && } {onOpenChart && }
)}
)}
); })}
); } // Current unrealized P&L for an open position: basis (avg → entry) vs latest mark. function posPnl(p) { const basis = p.avgPrice != null ? p.avgPrice : p.entryPrice; const mark = p.markPrice; const pnl = (basis && mark != null) ? (mark - basis) / basis : null; return { basis, mark, pnl }; } // At-a-glance summary strip — leads with P&L so you read the answer first. // Derived from ALL open positions (independent of the table's filters). function PositionsSummary({ positions, recaps }) { const s = useMemo(() => { const open = positions.filter(p => p.status !== "closed" && p.status !== "expired"); const marks = open.map(posPnl).filter(x => x.pnl != null); const greens = marks.filter(x => x.pnl >= 0).length; const reds = marks.filter(x => x.pnl < 0).length; const avg = marks.length ? marks.reduce((a, x) => a + x.pnl, 0) / marks.length : null; let mover = null; for (const p of open) { const { pnl } = posPnl(p); if (pnl == null) continue; if (!mover || Math.abs(pnl) > Math.abs(mover.pnl)) mover = { ticker: p.ticker, analyst: p.analyst, pnl }; } const weekAgo = Date.now() - 7 * 86400000; const closedWk = (recaps || []).filter(r => r.updatedTs >= weekAgo); const wWk = closedWk.filter(r => r.pnlPct >= 0).length; // Ledger extras: how many open positions expire this week, and how many have // gone quiet (no analyst update in 2+ days) — the honesty meter. const wkEnd = Date.now() + 7 * 86400000; const expiring = open.filter(p => isOption(p) && p.expiry && (() => { const d = dteOf(p.expiry); return d != null && d >= 0 && d <= 7; })()).length; const stale = open.filter(p => markAge(p.updatedTs) === "stale").length; return { open: open.length, marked: marks.length, greens, reds, avg, mover, closedWk: closedWk.length, wWk, lWk: closedWk.length - wWk, expiring, stale }; }, [positions, recaps]); return (
{I("trend", { size: 11 })} {window.LEDGER_UI ? <>Avg stated P&L : <>Open P&L · avg}
= 0 ? "up" : "down"))}>{s.avg != null ? fmtPct(s.avg) : "—"}
{s.marked} of {s.open} marked
{I("table", { size: 11 })} Open positions
{s.open}
{s.marked ? <>{s.greens} ▲ · {s.reds} ▼ : "awaiting marks"}
{window.LEDGER_UI ? (
{I("activity", { size: 11 })} Expiring this week
0 && "val-warn")}>{s.expiring}
{s.stale ? <>{s.stale} not updated in 2d+ : "all marks current"}
) : (
{I("activity", { size: 11 })} Biggest mover
{s.mover ?
= 0 ? "up" : "down")}>${s.mover.ticker} {fmtPct(s.mover.pnl)}
:
—
}
{s.mover ? s.mover.analyst : "no marks yet"}
)}
{I("recap", { size: 11 })} Closed this week
{s.closedWk}
{s.closedWk ? <>{s.wWk}W / {s.lWk}L : "none yet"}
); } // ── Positions has TWO maintained layouts — flip GLANCE_UI in app.jsx to switch. // • Positions (default) — the at-a-glance build: P&L-led table (left bar + big // % cell), Winners/Losers/Today segments, details in the expand panel. // • PositionsClassic — the prior 12-column table (Expiry/Strike/Stop/Conf // inline). Kept so we can revert instantly if the new view doesn't land. function PositionsClassic({ positions, events, analysts, servers, filter, days, onPickTicker, onOpenChart, onLogEvent, canManageRow, showParser, onEditEvent, canEditEvent, onEditPosition }) { const isMobile = useIsMobile(); const [sort, setSort] = useState({ key: "updatedTs", dir: "desc" }); const [expanded, setExpanded] = useState(null); const [inst, setInst] = useState("all"); const [anFilter, setAnFilter] = useState(() => new Set()); const [calcPos, setCalcPos] = useState(null); const [managePos, setManagePos] = useState(null); const [logOpen, setLogOpen] = useState(false); const cutoff = Date.now() - days * 86400000; // Analysts that actually have an open position in range — populates the filter. const availableAnalysts = useMemo(() => { const set = new Set(); for (const p of positions) { if (p.status === "closed" || p.status === "expired") continue; if (p.updatedTs < cutoff) continue; if (!matchesInstrument(p, inst)) continue; set.add(p.analyst); } return [...set].sort(); }, [positions, cutoff, inst]); const filteredPositions = useMemo(() => { const fl = filter.toLowerCase().trim(); return positions .filter(p => p.status !== "closed" && p.status !== "expired") .filter(p => p.updatedTs >= cutoff) .filter(p => matchesInstrument(p, inst)) .filter(p => analystMatch(p.analyst, anFilter)) .filter(p => { if (!fl) return true; return p.ticker.toLowerCase().includes(fl); }); }, [positions, filter, cutoff, inst, anFilter]); const sorted = useMemo(() => { const arr = [...filteredPositions]; const dir = sort.dir === "asc" ? 1 : -1; arr.sort((a, b) => { const av = a[sort.key], bv = b[sort.key]; if (typeof av === "number" && typeof bv === "number") return (av - bv) * dir; return String(av || "").localeCompare(String(bv || "")) * dir; }); return arr; }, [filteredPositions, sort]); function setSortKey(k) { setSort(s => s.key === k ? { ...s, dir: s.dir === "asc" ? "desc" : "asc" } : { key: k, dir: "desc" }); } const sortInd = (k) => sort.key === k ? (sort.dir === "asc" ? "↑" : "↓") : "↕"; return ( <>
Open Positions
{onLogEvent && }
{sorted.length} active
{isMobile ? ( ) : ( {sorted.flatMap(p => { const isExpanded = expanded === p.key; const lastEvent = p.events[p.events.length-1]; const rcy = recencyBucket(p.updatedTs); const rows = [ setExpanded(isExpanded ? null : p.key)}> ]; if (isExpanded) { rows.push( ); } return rows; })} {sorted.length === 0 && ( )}
setSortKey("analyst")} className={cx("sortable", sort.key==="analyst" && "active")}>Analyst {sortInd("analyst")} setSortKey("ticker")} className={cx("sortable", sort.key==="ticker" && "active")}>Ticker {sortInd("ticker")} Instrument Expiry Strike Stop setSortKey("entryPrice")} className={cx("sortable num", sort.key==="entryPrice" && "active")} style={{textAlign:"right"}}>Entry → Now {sortInd("entryPrice")} setSortKey("updatedTs")} className={cx("sortable", sort.key==="updatedTs" && "active")}>Updated {sortInd("updatedTs")} setSortKey("lastAction")} className={cx("sortable", sort.key==="lastAction" && "active")}>Action {sortInd("lastAction")} setSortKey("lastConfidence")} className={cx("sortable", sort.key==="lastConfidence" && "active")}>Conf {sortInd("lastConfidence")} Last alert
${p.ticker} {isOption(p) && p.expiry ? {fmtExpiry(p.expiry)} : —} {isOption(p) && p.strike != null ? {p.strike} : —} {p.stopLoss != null ? {fmtNum(p.stopLoss)} : —} {(() => { const basis = p.avgPrice != null ? p.avgPrice : p.entryPrice; if (!basis) return "—"; return ( <> {fmtNum(basis)} {p.avgPrice != null && avg} {p.markPrice != null && (() => { const up = p.markPrice >= basis; const pnl = (p.markPrice - basis) / basis; return ( → {fmtNum(p.markPrice)} ({fmtPct(pnl)}) ); })()} ); })()} {!isExpanded && rcy === "live" && NEW}{fmtTime(p.updatedTs, { short: true })} {p.lastNote} {onLogEvent && (!canManageRow || canManageRow(p)) && } {onOpenChart && }

All interactions · {p.events.length}

{showParser && }
)}
{calcPos && setCalcPos(null)} />} {managePos && setManagePos(null)} onSubmit={onLogEvent} />} {logOpen && setLogOpen(false)} onSubmit={onLogEvent} />} ); } // The signature motif of the analyst-first landing: a slim segmented bar showing // an analyst's book health — up / down / still-unmarked — proportioned by count. // Unmarked stays a neutral segment (never implies a live mark it doesn't have), // and semantic colours are never the analyst's identity accent. Reused full-size // in each roster row and as an 88px mini on mobile. function BookMeter({ up, down, count }) { const un = Math.max(0, count - up - down); const segs = []; if (up > 0) segs.push(["bm-up", up]); if (down > 0) segs.push(["bm-down", down]); if (un > 0) segs.push(["bm-un", un]); return ( {segs.map(([cls, v]) => )} ); } // Analyst-first landing (per-server setting `positions_by_analyst`): instead of a // flat list of every open play, an EDITORIAL ROSTER — one full-bleed row per // analyst (league-table idiom, no cards), ranked by open count, each showing // their book health, avg stated P&L, holdings and what's expiring. Drill into // one to see their positions. Fills the width by construction, so a 3-analyst // book never reads as a sparse grid; reflows to a clean stack on mobile via CSS. function AnalystOverview({ positions, analysts, onPick }) { const groups = useMemo(() => { const m = new Map(); for (const p of positions) { const a = m.get(p.analyst) || []; a.push(p); m.set(p.analyst, a); } const out = [...m.entries()].map(([handle, ps]) => { const marks = ps.filter(x => x._pnl != null); const up = marks.filter(x => x._pnl >= 0).length; const down = marks.filter(x => x._pnl < 0).length; const avg = marks.length ? marks.reduce((s, x) => s + x._pnl, 0) / marks.length : null; let best = null, worst = null; for (const x of marks) { if (!best || x._pnl > best._pnl) best = x; if (!worst || x._pnl < worst._pnl) worst = x; } const expiring = ps.filter(x => isOption(x) && x.expiry && (() => { const d = dteOf(x.expiry); return d != null && d >= 0 && d <= 7; })()).length; // Distinct tickers, freshest-updated first — a peek at what they're holding. const seen = new Set(); const tickers = []; for (const x of [...ps].sort((a, b) => b.updatedTs - a.updatedTs)) { if (!seen.has(x.ticker)) { seen.add(x.ticker); tickers.push(x.ticker); } } const a = (analysts || []).find(x => x.handle === handle); return { handle, count: ps.length, up, down, avg, best, worst, expiring, tickers, color: a?.color || "var(--accent)", avatarUrl: a?.avatarUrl }; }); // Rank by activity; tie-breaks are deterministic (avg desc, then handle) so // the order and the "Most open" lede don't jitter between live polls. out.sort((x, y) => y.count - x.count || ((y.avg ?? -Infinity) - (x.avg ?? -Infinity)) || x.handle.localeCompare(y.handle)); return out; }, [positions, analysts]); if (!groups.length) return ; const n = groups.length; const sparse = n <= 4; // a low count earns row height with real data, not padding const totalOpen = groups.reduce((a, g) => a + g.count, 0); const totalExp = groups.reduce((a, g) => a + g.expiring, 0); const allMarks = positions.filter(p => p._pnl != null); const bookAvg = allMarks.length ? allMarks.reduce((s, p) => s + p._pnl, 0) / allMarks.length : null; return (
{groups.map((g, idx) => { const marked = g.up + g.down; const unmarked = g.count - marked; const lead = sparse && idx === 0; const chips = g.tickers.slice(0, 5); const extra = g.tickers.length - chips.length; return ( ); })}
{n} analyst{n === 1 ? "" : "s"} · {totalOpen} open{bookAvg != null && <> · avg = 0 ? "up" : "down"}>{fmtPct(bookAvg)}}{totalExp > 0 && <> · {totalExp} expiring this week}
); } function Positions({ positions, events, analysts, servers, filter, days, analystFirst, onPickTicker, onOpenChart, onLogEvent, canManageRow, showParser, onEditEvent, canEditEvent, onEditPosition }) { const isMobile = useIsMobile(); const [sort, setSort] = useState({ key: "updatedTs", dir: "desc" }); const [expanded, setExpanded] = useState(null); const [inst, setInst] = useState("all"); const [anFilter, setAnFilter] = useState(() => new Set()); const [seg, setSeg] = useState("all"); // all | winners | losers | today const [calcPos, setCalcPos] = useState(null); const [managePos, setManagePos] = useState(null); const [logOpen, setLogOpen] = useState(false); const cutoff = Date.now() - days * 86400000; // "Today" = the current MARKET day, not the viewer's calendar day — otherwise // a Malaysian morning would call the previous NY session "today". const todayKey = marketToday(); const todayStart = (() => { const d = marketDayDate(todayKey); return d ? d.getTime() : 0; })(); // Analysts that actually have an open position in range — populates the filter. const availableAnalysts = useMemo(() => { const set = new Set(); for (const p of positions) { if (p.status === "closed" || p.status === "expired") continue; if (p.updatedTs < cutoff) continue; if (!matchesInstrument(p, inst)) continue; set.add(p.analyst); } return [...set].sort(); }, [positions, cutoff, inst]); // Open positions in range, decorated with current P&L (the at-a-glance anchor). const decorated = useMemo(() => { const fl = filter.toLowerCase().trim(); return positions .filter(p => p.status !== "closed" && p.status !== "expired") .filter(p => p.updatedTs >= cutoff) .filter(p => matchesInstrument(p, inst)) .filter(p => analystMatch(p.analyst, anFilter)) .filter(p => !fl || p.ticker.toLowerCase().includes(fl)) .map(p => { const { basis, mark, pnl } = posPnl(p); return { ...p, _basis: basis, _mark: mark, _pnl: pnl }; }); }, [positions, filter, cutoff, inst, anFilter]); // Quick segments — Winners / Losers / Today (Today = the current MARKET day). // Compare market-day KEYS, never a timestamp against a local-midnight anchor: // the anchor sits at a different instant than the trading day it names. const isToday = (p) => marketDayKey(p.updatedTs) === todayKey; const segCounts = useMemo(() => ({ all: decorated.length, winners: decorated.filter(p => p._pnl != null && p._pnl >= 0).length, losers: decorated.filter(p => p._pnl != null && p._pnl < 0).length, today: decorated.filter(isToday).length, }), [decorated, todayKey]); const segFiltered = useMemo(() => { if (seg === "winners") return decorated.filter(p => p._pnl != null && p._pnl >= 0); if (seg === "losers") return decorated.filter(p => p._pnl != null && p._pnl < 0); if (seg === "today") return decorated.filter(isToday); return decorated; }, [decorated, seg, todayKey]); const sorted = useMemo(() => { const arr = [...segFiltered]; const dir = sort.dir === "asc" ? 1 : -1; arr.sort((a, b) => { const av = a[sort.key], bv = b[sort.key]; if (sort.key === "_pnl") { if (av == null && bv == null) return 0; if (av == null) return 1; // unmarked sink to the bottom if (bv == null) return -1; return (av - bv) * dir; } if (typeof av === "number" && typeof bv === "number") return (av - bv) * dir; return String(av || "").localeCompare(String(bv || "")) * dir; }); return arr; }, [segFiltered, sort]); function setSortKey(k) { setSort(s => s.key === k ? { ...s, dir: s.dir === "asc" ? "desc" : "asc" } : { key: k, dir: "desc" }); } const sortInd = (k) => sort.key === k ? (sort.dir === "asc" ? "↑" : "↓") : "↕"; // Analyst-first landing: overview (no analyst picked) vs drilled into one. const overviewMode = analystFirst && anFilter.size === 0; const drillAnalyst = analystFirst && anFilter.size === 1 ? [...anFilter][0] : null; const analystCount = new Set(decorated.map(p => p.analyst)).size; // A clear, contextual empty state — so a segment filtering everything out never // reads as a broken/blank page (the "All + Today shows nothing" confusion). const emptyMsg = seg === "today" ? "No open positions were active in today's market session." : seg === "winners" ? "No open positions are up right now." : seg === "losers" ? "No open positions are down right now." : "No open positions match this filter."; return ( <>
{drillAnalyst ? ( {drillAnalyst} ) : "Open Positions"}
{onLogEvent && } {!overviewMode && (
{[["all", "All"], ["winners", "Winners"], ["losers", "Losers"], ["today", "Today"]].map(([v, l]) => ( ))}
)} {!analystFirst && }
{overviewMode ? `${analystCount} analyst${analystCount === 1 ? "" : "s"}` : `${sorted.length} active`}
{overviewMode ? ( setAnFilter(new Set([h]))} /> ) : sorted.length === 0 ? (

{emptyMsg}

{seg !== "all" && }
) : isMobile ? ( ) : ( {sorted.flatMap(p => { const isExpanded = expanded === p.key; const lastEvent = p.events[p.events.length-1]; const rcy = recencyBucket(p.updatedTs); const ledger = !!window.LEDGER_UI; const age = ledger ? markAge(p.updatedTs) : null; // fresh | aging | stale const dte = ledger && isOption(p) ? dteOf(p.expiry) : null; // contract math, no feed const anColor = (analysts.find(a => a.handle === p.analyst) || {}).color || "var(--accent)"; const rows = [ = 0 ? "pnl-up" : "pnl-down"), ledger && "pos-row-led")} style={ledger ? { "--an-col": anColor } : undefined} onClick={() => setExpanded(isExpanded ? null : p.key)}> ]; if (isExpanded) { rows.push( ); } return rows; })} {sorted.length === 0 && ( )}
setSortKey("analyst")} className={cx("sortable", sort.key==="analyst" && "active")}>Analyst {sortInd("analyst")} setSortKey("ticker")} className={cx("sortable", sort.key==="ticker" && "active")}>Ticker {sortInd("ticker")} Instrument setSortKey("_pnl")} className={cx("sortable num", sort.key==="_pnl" && "active")} style={{textAlign:"right"}} title={window.LEDGER_UI ? "Computed from the prices analysts stated in Discord — not market data" : undefined}> {window.LEDGER_UI ? <>P&L · entry → last stated : <>P&L · entry → now} {sortInd("_pnl")} setSortKey("lastAction")} className={cx("sortable", sort.key==="lastAction" && "active")}>Action {sortInd("lastAction")} setSortKey("updatedTs")} className={cx("sortable", sort.key==="updatedTs" && "active")}>{window.LEDGER_UI ? "Last analyst update" : "Updated"} {sortInd("updatedTs")} Last alert
${p.ticker} {ledger && {p.events.length} event{p.events.length === 1 ? "" : "s"}} {dte != null && {dteLabel(dte)}} {isOption(p) && (p.strike != null || p.expiry) && (
{p.strike != null && {strikeText(p)}} {p.strike != null && p.expiry && · } {p.expiry && {fmtExpiry(p.expiry)}}
)} 		{p._pnl != null ? ( <> {/* P&L% swaps INSTANTLY in steady sign colour — flashing a derived number doubles the motion and adds nothing the mark flash doesn't. The arrow is PERSISTENT and coloured by SIGN, so direction is never colour-only (WCAG 1.4.1). */} = 0 ? "up" : "down")}> {p._lq && = 0 ? "up" : "down")} aria-hidden="true">{p._pnl >= 0 ? "▲" : "▼"}} {fmtPct(p._pnl)} {fmtPrice(p._basis, p.currency)}{p.avgPrice != null && avg} → {fmtPrice(p._mark, p.currency)} {p._lq ? : ledger && · {fmtAgo(p.updatedTs)}} {/* Option premium stays analyst-stated; show the underlying's live move as context. */} {!p._lq && p._lqUnderlying && ( {" "}· {p.ticker} {fmtNum(p._lqUnderlying.price)} = 0 ? "up" : "down")}>{p._lqUnderlying.dir >= 0 ? "▲" : "▼"} )} {p._lq && = 0} />} ) : (p._basis != null ? {fmtPrice(p._basis, p.currency)} entry{ledger && · no mark yet} : —)} {!isExpanded && rcy === "live" && NEW}{fmtTime(p.updatedTs, { short: true })} {p.lastNote} {onLogEvent && (!canManageRow || canManageRow(p)) && } {onOpenChart && }
Action
Conf
{isOption(p) &&
Expiry
{p.expiry ? fmtExpiry(p.expiry) : "—"}
} {isOption(p) &&
Strike
{p.strike != null ? p.strike : "—"}
}
Stop
{p.stopLoss != null ? {fmtPrice(p.stopLoss, p.currency)} : "—"}
Entry
{p._basis != null ? <>{fmtPrice(p._basis, p.currency)}{p.avgPrice != null && avg} : "—"}
{window.LEDGER_UI ? "Last stated" : "Mark"}
{p._mark != null ? fmtPrice(p._mark, p.currency) : "—"} {window.LEDGER_UI && p._mark != null && · {fmtAgo(p.updatedTs)}}
{window.LEDGER_UI && isOption(p) && dteOf(p.expiry) != null && (
Time left
{dteLabel(dteOf(p.expiry))}
)}
{window.LEDGER_UI &&
Every price here is a mark the analyst stated in Discord — not market data.
}

All interactions · {p.events.length}

{showParser && }
)}
{calcPos && setCalcPos(null)} />} {managePos && setManagePos(null)} onSubmit={onLogEvent} />} {logOpen && setLogOpen(false)} onSubmit={onLogEvent} />} ); } // Cost calculator: contracts → cost, or budget → whole contracts. function PositionCalc({ position, onClose }) { const isOpt = isOption(position); const mult = isOpt ? 100 : 1; const unitOne = isOpt ? "contract" : "share"; const unitN = (n) => `${n} ${isOpt ? "contract" : "share"}${n === 1 ? "" : "s"}`; const basePrice = position.markPrice ?? position.avgPrice ?? position.entryPrice ?? position.lastPrice ?? 0; const [price, setPrice] = useState(basePrice ? String(basePrice) : ""); const [qty, setQty] = useState(""); const [budget, setBudget] = useState(""); useEffect(() => { const onKey = (e) => { if (e.key === "Escape") onClose(); }; window.addEventListener("keydown", onKey); return () => window.removeEventListener("keydown", onKey); }, []); const p = Number(price); const valid = isFinite(p) && p > 0; const perUnit = valid ? p * mult : 0; const nQty = Math.max(0, Math.floor(Number(qty) || 0)); const qtyCost = perUnit * nQty; const bud = Number(budget) || 0; const buyable = valid && bud > 0 ? Math.floor(bud / perUnit) : 0; const buyableCost = buyable * perUnit; const leftover = bud - buyableCost; return (
e.stopPropagation()}>
${position.ticker} {contractText(position) || (isOpt ? "option" : "shares")}
{isOpt ? "1 contract = 100 shares" : "share calculator"}
{valid ?
1 {unitOne} = {fmtCurrency(perUnit)}{isOpt && <> ({fmtNum(p)} × 100)}
:
Enter a price to calculate.
}
{isOpt ? "Contracts" : "Shares"} → cost
setQty(e.target.value)} placeholder="0" />{isOpt ? "ct" : "sh"}
Total cost {valid && nQty > 0 ? fmtCurrency(qtyCost) : "—"}
Budget → {isOpt ? "contracts" : "shares"}
$ setBudget(e.target.value)} placeholder="0" />
{valid && bud > 0 ? (buyable > 0 ? <>{unitN(buyable)}{fmtCurrency(buyableCost)} : Not within budget — 1 {unitOne} is {fmtCurrency(perUnit)}.) : <>Whole {isOpt ? "contracts" : "shares"}—}
{valid && buyable > 0 &&
{fmtCurrency(leftover)} left over
}
); } // Admin-only: manually log a position update (close / trim / add / cut / update) // from the portal. Posts a real event attributed to the position's analyst, so it // flows into positions, recaps and charts exactly like a parsed Discord post. function PositionManage({ position, onClose, onSubmit }) { const p = position; const opt = isOption(p); const basis = p.avgPrice != null ? p.avgPrice : p.entryPrice; const ACTIONS = [ { k: "add", label: "Add", hint: "Bought more — adds to the position." }, { k: "trim", label: "Trim", hint: "Sold part — banks profit, keeps runners open." }, { k: "close", label: "Close", hint: "Full exit — moves it to recaps." }, { k: "cut", label: "Cut", hint: "Stopped out — closes the position." }, { k: "hold", label: "Update", hint: "No buy or sell — just refresh the mark / stop." }, ]; const [action, setAction] = useState("hold"); // default to "Update" (refresh mark/stop), not Trim const [price, setPrice] = useState(""); const [priceMode, setPriceMode] = useState("$"); // "$" fill price, or "%" gain from entry (auto-computes $) const [addMode, setAddMode] = useState("fill"); // for an Add: "fill" (price added at) or "avg" (new blended average) const [mark, setMark] = useState(""); const [stop, setStop] = useState(p.stopLoss != null ? String(p.stopLoss) : ""); const [note, setNote] = useState(""); const [busy, setBusy] = useState(false); useEffect(() => { const onKey = (e) => { if (e.key === "Escape" && !busy) onClose(); }; window.addEventListener("keydown", onKey); return () => window.removeEventListener("keydown", onKey); }, [busy]); const cur = ACTIONS.find(a => a.k === action) || ACTIONS[0]; const isExit = action === "close" || action === "cut"; const isUpdate = action === "hold"; const priceLabel = action === "add" ? (addMode === "avg" ? "New average" : "Add fill price") : isExit ? "Exit price" : "Trim fill price"; // A % gain only makes sense on a trim/exit (gain vs entry). For an add it's a new // entry, so keep $ only. When % is chosen, auto-compute the dollar fill from entry. const allowPct = action === "trim" || isExit; const effMode = allowPct ? priceMode : "$"; const pctSign = (p.instrument === "shares" && p.direction === "short") ? -1 : 1; const computedFromPct = (effMode === "%" && basis != null && price !== "" && isFinite(Number(price))) ? basis * (1 + pctSign * Number(price) / 100) : null; async function submit() { if (busy) return; if (!p.guildId) { toast.error("This position has no server context — can't log."); return; } const addAvg = action === "add" && addMode === "avg"; const numPrice = price !== "" ? Number(price) : null; const payload = { guild_id: p.guildId, analyst_handle: p.analyst, analyst_user_id: p.analystUserId, ticker: p.ticker, action, instrument: p.instrument, contract: p.contract, strike: p.strike, expiry: p.expiry, option_type: p.optionType, direction: p.direction, // In "New avg" mode the input IS the new blended average (→ avg_price), so // the cost basis updates — an add can't re-blend on its own without share // counts. Otherwise it's the fill price, exactly as before. price: addAvg ? null : effMode === "%" ? (computedFromPct != null ? Number(computedFromPct.toFixed(4)) : null) : numPrice, avg_price: addAvg ? numPrice : null, current_price: mark !== "" ? Number(mark) : null, stop_loss: stop !== "" ? Number(stop) : null, note: note.trim() || null, }; setBusy(true); const ok = await onSubmit(payload); setBusy(false); if (ok) onClose(); } return (
!busy && onClose()}>
e.stopPropagation()}>
${p.ticker} {contractText(p) || (opt ? "option" : "shares")}
Log a manual update · {p.analyst}
entry {basis != null ? fmtNum(basis) : "—"} mark {p.markPrice != null ? fmtNum(p.markPrice) : "—"} stop {p.stopLoss != null ? fmtNum(p.stopLoss) : "—"}
{ACTIONS.map(a => ( ))}
{cur.hint}
{!isUpdate && ( )} {(action === "add" || action === "trim" || isUpdate) && ( )}