{shown.map((p, i) => (
);
}
// ── timestamps ─────────────────────────────────────────────────────────────
// A bare "2026-10-06 16:05:00" is UTC by convention here, so it gets a Z; a value that
// already says its zone ("...Z", "...+00:00") is parsed as is — appending a Z to one with an
// offset made it unparseable and every such time rendered as "—".
function parseIso(iso) {
if (!iso) return null;
const s = String(iso);
const t = Date.parse(/(Z|[+-]\d\d:?\d\d)$/i.test(s) ? s : s + 'Z');
return Number.isFinite(t) ? t : null;
}
// "1d 21h", "3h 12m", "8m": precise enough to read an open trade's age at a glance.
function ageLong(iso) {
const t = parseIso(iso);
if (t === null) return '—';
const s = Math.max(0, (Date.now() - t) / 1000);
const d = Math.floor(s / 86400), h = Math.floor((s % 86400) / 3600), m = Math.floor((s % 3600) / 60);
if (d > 0) return d + 'd ' + h + 'h';
if (h > 0) return h + 'h ' + m + 'm';
return m + 'm';
}
function fmtStamp(iso) {
const t = parseIso(iso);
if (t === null) return '—';
return new Date(t).toLocaleString('en-GB', {
timeZone: 'UTC', day: '2-digit', month: 'short', hour: '2-digit', minute: '2-digit', hour12: false,
}) + ' UTC';
}
// "4h 01m": the gap between the trader posting and the signal reaching us.
function gapLong(fromIso, toIso) {
const a = parseIso(fromIso), b = parseIso(toIso);
if (a === null || b === null) return null;
const m = Math.round(Math.abs(b - a) / 60000);
return Math.floor(m / 60) + 'h ' + String(m % 60).padStart(2, '0') + 'm';
}
function OpenedCell({ r }) {
const gap = gapLong(r.trader_posted_utc, r.created_at);
const tip = [
'Paper entry: this signal reached us at ' + fmtStamp(r.created_at) + '.',
r.entry_price != null ? 'The entry price (' + fmtNum(r.entry_price) + ') is the market price at that moment.' : null,
r.trader_posted_utc
? 'The trader posted it at ' + fmtStamp(r.trader_posted_utc) + (gap ? ', ' + gap + ' earlier: the source channel is a delayed mirror.' : '.')
: null,
'Nothing was executed on the exchange (shadow mode).',
].filter(Boolean).join(' ');
return (
{ageLong(r.created_at)}
{fmtStamp(r.created_at)}
);
}
// ── entry eligibility marker ───────────────────────────────────────────────
// Live trading would have skipped this setup. Paper records it anyway so the scorecard
// can compare the two groups, and this is where that verdict becomes visible.
const ELIG_WHY = {
DRIFT_EXCEEDS_TOLERANCE: 'price had already run past the entry band by the time it reached us',
REMAINING_RR_BELOW_FLOOR: 'too little reward was left for the risk',
SL_TOUCHED_SINCE_POST: 'price had already hit the stop after he posted it',
TP1_REACHED_SINCE_POST: 'price had already reached the first target after he posted it',
PULLED_BACK_BEYOND_TOLERANCE: 'price had pulled back beyond the entry band',
AGE_BACKSTOP: 'it was too old by the time it reached us',
PRICE_PATH_UNAVAILABLE: 'there was no price data to check it against (fails closed)',
STOP_NOT_ON_LOSING_SIDE_OF_REFERENCE: 'the stop was on the wrong side of the entry',
};
function EligMark({ r }) {
if (r.eligible !== 0) return null; // eligible, or never assessed: nothing to say
const why = ELIG_WHY[r.eligibility_reason] || r.eligibility_reason || 'ineligible';
const drift = r.drift_r != null ? ' Drift from his entry: ' + (r.drift_r >= 0 ? '+' : '−') + Math.abs(r.drift_r).toFixed(2) + 'R.' : '';
return (
would skip live
);
}
// ── live price, flashing on a tick ─────────────────────────────────────────
// Colour follows the direction of the last move (bull/bear are reserved for exactly
// this sign), and fades. Nothing flashes on first load: there is no prior price.
function LivePrice({ value, entry }) {
const prev = useR(null);
const [dir, setDir] = useS(null);
useE(() => {
if (value == null) return undefined;
const was = prev.current;
prev.current = value;
if (was == null || value === was) return undefined;
setDir(value > was ? 'up' : 'down');
const id = setTimeout(() => setDir(null), 1200);
return () => clearTimeout(id);
}, [value]);
const tone = dir === 'up' ? 'var(--bull)' : dir === 'down' ? 'var(--bear)' : 'var(--text)';
const bg = dir === 'up' ? 'var(--bull-bg)' : dir === 'down' ? 'var(--bear-bg)' : 'transparent';
return (
{(dir === 'up' ? '▲ ' : dir === 'down' ? '▼ ' : '') + fmtNum(value)}
{entry != null && (
(entry {fmtNum(entry)})
)}
);
}
// ── paper P&L cell ─────────────────────────────────────────────────────────
const ENTRY_BASIS = {
market_when_seen: 'the market price when the signal reached us',
stated: "the trader's stated limit price",
stated_bound: "the trader's stated bound (no market price was available)",
};
function signedPct(v) { return (v >= 0 ? '+' : '−') + Math.abs(v).toFixed(2) + '%'; }
function signedR(v) { return (v >= 0 ? '+' : '−') + Math.abs(v).toFixed(2) + 'R'; }
// A trade that enters in pieces is not fully in just because one piece is: say how much is. Single
// entries show nothing. ("Partly closed" is a different thing: the trader took profit.)
function EntryProgress({ r }) {
if (r.state !== 'LIVE' && r.state !== 'PARTIAL') return null;
let text = null, tip = '';
if (r.split_legs > 1 && r.legs_reached != null) {
text = `entries ${r.legs_reached}/${r.split_legs} reached`;
tip = `This trade enters in ${r.split_legs} pieces and ${r.legs_reached} of them have been reached so far. This row is one piece.`;
} else if (r.entry_type === 'dca_zone' && r.entry_price_source === 'market_when_seen') {
text = 'averaging in';
tip = 'Started at the market, with more buys planned lower down to the zone the trader gave ("CMP till X"), so it is not at its full planned size yet.';
}
if (!text) return null;
return {text};
}
function PaperPnl({ r }) {
const p = r.paper;
// A resting limit/split entry that price hasn't reached yet since the signal
// arrived — nothing is in yet, so there is no P&L to mark, hypothetical or
// real. Shown distinctly from "no data" below: this IS data, it's just "not yet".
if (p && p.pending) {
return pending entry;
}
// No entry price or no live mark: say so. A blank would read as flat, and 0 as a
// real result.
if (!p || p.pnl_pct == null) {
return —;
}
const up = p.pnl_pct >= 0;
const color = Math.abs(p.pnl_pct) < 0.005 ? 'var(--text-3)' : up ? 'var(--bull)' : 'var(--bear)';
const tip = [
'Paper P&L: what a follower who entered at the signal would be up or down now.',
`Entry ${fmtNum(r.entry_price)} — ${ENTRY_BASIS[p.basis] || 'source unknown'}.`,
r.entry_filled_at ? `Entry reached at ${fmtStamp(r.entry_filled_at)}.` : null,
`Mark ${fmtNum(p.mark)} (Bybit mark price).`,
p.pnl_r != null
? `R is measured against the initial stop ${fmtNum(r.sl_initial)}, not the current one.`
: 'No initial stop recorded, so no R multiple.',
r.state === 'PARTIAL'
? 'Assumes full size since entry: profits the trader booked are NOT modelled.'
: 'Assumes full size since entry.',
].filter(Boolean).join(' ');
return (
{signedPct(p.pnl_pct)}
{p.pnl_r != null && (
{signedR(p.pnl_r)}
)}
);
}
// ── manual close: an operator safety valve, not the trader's stop/target ──
function ConfirmCloseModal({ target, onCancel, onConfirm, busy, error }) {
if (!target) return null;
const { row, exch, accountLabel } = target;
return (
setHover(i)} onMouseLeave={() => setHover(null)}
style={{
width: `${(p.value / total) * 100}%`, background: p.color,
opacity: hover == null || hover === i ? 1 : 0.45,
transition: 'opacity .12s', cursor: 'default',
}} />
))}
{/* legend always present, and every slice is directly labelled */}
{shown.map((p, i) => (
setHover(i)} onMouseLeave={() => setHover(null)}
style={{
display: 'flex', alignItems: 'center', gap: 8, fontSize: 11.5,
opacity: hover == null || hover === i ? 1 : 0.55,
}}>
{p.label}
{p.kind === 'balance' && !p.approx && (
· {fmtNum(p.qty)}
)}
{p.approx && · qty, not valued}
{((p.value / total) * 100).toFixed(1)}%
{p.approx ? fmtNum(p.value) : fmtUsd(p.value)}
))}
e.stopPropagation()} className="card" style={{ width: 380, maxWidth: '90vw' }}>
{error &&
⚠ Close position now
This sends a real reduce-only market order on {row.symbol} ({row.side})
{accountLabel && <> on account {accountLabel}} and flattens it immediately —
ahead of the trader's own stop or target. This cannot be undone.
Contracts
{fmtNum(exch && exch.contracts)}
Entry
{fmtNum(exch && exch.entry_price)}
Unrealized P&L
= 0 ? 'var(--bull)' : 'var(--bear)' }}>
{exch && exch.unrealized_pnl != null ? fmtUsd(exch.unrealized_pnl) : '—'}
{error}
}
e.stopPropagation()} className="card" style={{ width: 400, maxWidth: '90vw' }}>
Resend to your account
Re-checks {row.symbol} ({row.side}) against the current price — refuses if it's
drifted out of tolerance, already hit stop or target, or your account has no room —
and only places a real order if your account is live and it's still a valid entry.
{error && (
{error}
)}
{result && result.ok && (
Sent — {result.qty != null ? `${fmtNum(result.qty)} @ ${fmtNum(result.avg_fill)}` : (result.sizing || 'order placed')}.
)}
{!(result && result.ok) && (
)}
e.stopPropagation()} className="card" style={{ width: 420, maxWidth: '90vw' }}>
Re-analyze SL/TP/entry
Re-reads the original message for {row.symbol} ({row.side}) — text and
chart alike — with today's extraction, and fills in SL, targets, or entry price
only where this signal still has none on record. Never overwrites a value
that's already there, and never touches state, side, or any position.
{error && (
{error}
)}
{result && result.ok && (
{result.changed ? `Updated: ${result.fields.join(', ')}.` : (result.detail || 'Nothing missing was found.')}
)}
{!(result && result.ok) && (
)}
!busy && onClose()}>
);
}
function CreateSignalModal({ target, onClose, onSaved }) {
const [form, setForm] = useS({});
const [busy, setBusy] = useS(false);
const [result, setResult] = useS(null);
useE(() => {
if (!target) return;
const ex = target.extraction || {};
setForm({
symbol: (ex.symbol || target.symbol || '').toUpperCase(),
side: ex.side || target.side || '',
entry_price: String(ex.entry_price ?? ex.entry_reference ?? ''),
sl: String(ex.sl ?? ''),
tps: (ex.tps || []).join(', '),
entry_type: ex.entry_type || 'cmp',
});
setResult(null);
}, [target]);
if (!target) return null;
const upd = (k, v) => setForm(f => ({ ...f, [k]: v }));
async function submit() {
if (!form.symbol.trim() || !form.side) return setResult({ ok: false, error: 'Symbol and side are required' });
setBusy(true); setResult(null);
const tpsArr = form.tps.trim()
? form.tps.split(',').map(s => Number(s.trim())).filter(n => Number.isFinite(n))
: [];
const body = {
sub_event_id: target.id,
symbol: form.symbol.trim().toUpperCase(),
side: form.side,
entry_price: form.entry_price !== '' ? Number(form.entry_price) : null,
sl: form.sl !== '' ? Number(form.sl) : null,
tps: tpsArr.length ? tpsArr : null,
entry_type: form.entry_type || null,
};
const r = await fetch('/api/signals/create-manual', {
method: 'POST', headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(body),
}).then(x => x.json()).catch(e => ({ ok: false, error: String(e.message || e) }));
setBusy(false);
setResult(r);
if (r.ok) setTimeout(() => { onSaved(r.signal_id); onClose(); }, 600);
}
const inp = { background: 'var(--bg-input)', border: '1px solid var(--border-soft)',
borderRadius: 6, padding: '6px 10px', color: 'var(--text)', fontSize: 13,
fontFamily: 'var(--font-mono)', width: '100%', boxSizing: 'border-box' };
const lbl = { fontSize: 11, color: 'var(--text-3)', marginBottom: 2, display: 'block' };
return (
e.stopPropagation()} className="card" style={{ width: 420, maxWidth: '100%' }}>
{err &&
{hasRealPos ? 'Fix signal record' : 'Edit ledger entry'}
{hasRealPos
? <>This signal has a real exchange position. Changes here fix the ledger record only — the exchange position is not touched.
: <>No exchange position is held — safe to fix. Saving updates the ledger only;
"Save & resend" also re-checks entry against the current price.}
{!hasRealPos &&
Symbol
setForm({ ...form, symbol: e.target.value })} />
}
{hasRealPos &&
Symbol
}
Side
Entry
setForm({ ...form, entry_price: e.target.value })} />
Stop
setForm({ ...form, sl: e.target.value })} />
Target
setForm({ ...form, tp: e.target.value })} />
{err}
}
{!hasRealPos && }
{!hasRealPos && }
{!hasRealPos && }
{confirmAction === 'close' && (
Mark this trade as closed and move it to history?
)}
{confirmAction === 'cancel' && (
Close price (optional)
setCloseForm(f => ({ ...f, price: e.target.value }))} />
Closed at (optional)
setCloseForm(f => ({ ...f, at: e.target.value }))} />
Leave either blank to skip the price or use right now as the close time.
Remove this from the ledger entirely?
)}
e.stopPropagation()} className="card" style={{
width: 420, maxWidth: '95vw', padding: 0,
}}>
Add to ledger
upd('symbol', e.target.value)} style={inp} />
upd('entry_price', e.target.value)} style={inp} />
upd('sl', e.target.value)} style={inp} />
upd('tps', e.target.value)} style={inp}
placeholder="comma-separated" />
Creates a new LIVE signal on the ledger, independent of whatever this message's
own gate decision was — edit any field before saving. Timestamp matches the message.
{result && (
{result.ok ? 'Added to ledger (signal #' + result.signal_id + ')' : result.error}
)}
!busy && onClose()}>
);
}
// A sticky was tried here (2026-10-06) and reverted the same day: the
// table's horizontally-scrolling wrapper (overflowX: 'auto' below) implicitly
// computes overflow-y: auto too (CSS couples the two — one axis can't be
// non-visible while the other stays visible), which makes that div the
// sticky positioning's containing block. Since the div itself never actually
// scrolls vertically (its height just grows to fit content), position:
// sticky on a descendant never engages at all — confirmed with precise
// scroll-delta measurements showing the header moving in perfect lockstep
// with scroll, on both mobile and desktop widths, never catching. A correct
// fix needs a second, horizontally-synced header rendered outside that
// scrolling div, not attempted here.
// ── ledger vs the following accounts' positions ────────────────────────────
const POS_OPEN = ['ENTRY_WORKING', 'OPEN', 'PARTIAL'];
const POS_STATE_LABEL = {
ENTRY_WORKING: 'entering', OPEN: 'open', PARTIAL: 'partly closed',
CLOSED: 'closed', CANCELLED: 'cancelled', EXPIRED: 'expired', SKIPPED: 'skipped',
AWAITING_APPROVAL: 'awaiting approval',
};
// Shared by LedgerTable and StrategyPnlRow, computed once in the parent, so the
// table and the widgets above it are always looking at the identical filtered set
// — never two independent filter passes quietly drifting apart. Applies the
// account-env filter first (which positions even count), then decides per row
// whether anything real is left to show; matchedOnly drops rows where no account
// actually holds a position once that filter is applied.
// opts: sideFilter ('all'/'long'/'short'), driftFilter ('all'/'matched'/'drift'
// — matched means at least one open position survived the env filter above),
// accountFilter ('all' or an account_id, checked against the SAME env-filtered
// positions so the two compound correctly), openedSince/openedUntil (date
// strings, inclusive, against created_at — independent of period/customSince/
// customUntil, which are documented to never touch the open ledger).
function filterLedgerRows(rows, matchedOnly, envFilter, includeOrphans, opts = {}) {
const { sideFilter = 'all', driftFilter = 'all', accountFilter = 'all',
openedSince = '', openedUntil = '' } = opts;
const sinceT = openedSince ? Date.parse(openedSince + 'T00:00:00Z') : null;
const untilT = openedUntil ? Date.parse(openedUntil + 'T23:59:59Z') : null;
return rows.map(r => {
const positions = (r.positions || []).filter(p => envFilter === 'all' || p.account_env === envFilter);
return { ...r, positions, open: positions.filter(p => POS_OPEN.includes(p.state)) };
}).filter(r => {
if (matchedOnly && !r.open.length) return false;
if (includeOrphans && !r.open.length) return false;
if (envFilter !== 'all' && !r.positions.length) return false;
if (sideFilter !== 'all' && r.side !== sideFilter) return false;
if (driftFilter === 'matched' && !r.open.length) return false;
if (driftFilter === 'drift' && r.open.length) return false;
if (accountFilter !== 'all' && !r.positions.some(p => String(p.account_id) === String(accountFilter))) return false;
if (sinceT != null || untilT != null) {
if (!r.created_at) return false;
const t = Date.parse(String(r.created_at).endsWith('Z') ? r.created_at : r.created_at + 'Z');
if (!Number.isFinite(t)) return false;
if (sinceT != null && t < sinceT) return false;
if (untilT != null && t > untilT) return false;
}
return true;
});
}
// Small chip when SL/TP came from a manual path (UI edit or backfill). Raw source stays in title.
function ManualSourceChip({ source }) {
if (!source || !/manual/i.test(String(source))) return null;
const label = /backfill/i.test(String(source)) ? 'Manual backfill' : 'Manual';
return (
{label}
);
}
// ── Research Spec — per-coin trend confirm, own Binance data ───────────────
// Backed by research_trend_cache (Postgres), refreshed every 30 min by a cron
// job (scripts/research-trend-refresh.js) for whatever's currently in any
// ledger. GET /api/research/spec?symbol=X reads that cache and only falls
// back to a live (cooldown-limited) Binance fetch on a genuine cache miss —
// this never re-fetches on every click. Never invents a bias: Incomplete
// unless the cache has an actual computed trend.
const SPEC_CHECK_LABEL = { ema_stack: 'EMA stack', ema20_slope: 'EMA20 slope', rsi_agree: 'RSI agreement', macd_agree: 'MACD agreement' };
function specPhaseLabel(p) {
if (!p) return null;
if (p === 'v0_stub') return 'V0 stub';
if (p === 'v1_trend') return 'V1 trend';
if (p === 'v2_sector') return 'V2 sector';
return String(p).replace(/_/g, ' ');
}
function specSourceLabel(s) { return !s ? null : s === 'binance' ? 'Binance' : s === 'stub' ? 'stub' : String(s); }
function specBiasChip(b) { return b === 'bullish' ? 'chip bull' : b === 'bearish' ? 'chip bear' : 'chip neutral'; }
function specFormatAsOf(a) {
if (a == null || String(a).trim() === '') return null;
const d = new Date(a);
if (Number.isNaN(d.getTime())) return String(a);
try {
return d.toLocaleString('en-GB', {
timeZone: 'Europe/London', year: 'numeric', month: 'short', day: '2-digit',
hour: '2-digit', minute: '2-digit', hour12: false, timeZoneName: 'short',
});
} catch (e) { return String(a); }
}
const specLabelStyle = { fontSize: 10, letterSpacing: '0.08em', textTransform: 'uppercase', color: 'var(--text-4)', marginBottom: 4 };
function SpecMetaStrip({ data }) {
const symbol = data && data.symbol, asOfRaw = data && data.as_of, asOf = specFormatAsOf(asOfRaw);
const pL = specPhaseLabel(data && data.phase), sL = specSourceLabel(data && data.source);
const items = [];
if (symbol != null && String(symbol).trim() !== '') items.push({ k: 'Symbol', v: String(symbol), mono: true });
if (asOf) items.push({ k: 'As of', v: asOf, mono: true, title: asOfRaw ? String(asOfRaw) : undefined });
if (pL) items.push({ k: 'Phase', v: pL });
if (sL) items.push({ k: 'Source', v: sL });
if (!items.length) return null;
return (
e.stopPropagation()} className="card" style={{ width: 420, maxWidth: '100%' }}>
Edit position · {row.symbol} {row.side}
{pos.account_label ? ` · ${pos.account_label}` : ''}
{!result && (
<>
{summary.length > 0 && (
)}
{err &&
Changes are sent to the exchange immediately. Size can only be reduced (partial close).
Stop Loss
setForm({ ...form, sl: e.target.value })} />
Take Profit
{(pos.our_tps || []).length > 1 ? (
{(pos.our_tps || []).map((tp, i) => (
TP{i + 1}: {fmtNum(tp)}
))}
Multi-TP — edit not supported
) : (
setForm({ ...form, tp: e.target.value })} />
)}
Size (qty)
setForm({ ...form, size: e.target.value })} />
{summary.map((line, i) =>
)}
)}
{result && (
{line}
)}
Position updated
{(result.edits || []).map((e, i) => (
{e.field}: {fmtNum(e.old)} → {fmtNum(e.new)} {e.ok ? '✓' : `✗ ${e.reason || ''}`}
))}
{err}
}
{!result && (
)}
{items.map(it => (
))}
);
}
function SpecCheckRow({ check, idx }) {
const id = (check && check.id) || ('check-' + idx), pass = !!(check && check.pass), detail = (check && check.detail) || '';
const isAgree = id === 'rsi_agree' || id === 'macd_agree';
const cue = isAgree ? (pass ? 'Agrees' : 'No agree') : (pass ? 'Pass' : 'Fail');
return (
{it.k}
{it.v}
{(id && SPEC_CHECK_LABEL[id]) || String(id).replace(/_/g, ' ')}
{cue}
{detail ? String(detail) : No detail}
No trend (fail-closed)
;
const bias = trend.bias || 'neutral', checks = Array.isArray(trend.checks) ? trend.checks : [], tf = trend.timeframe ? String(trend.timeframe) : null;
return (
Bias
{String(bias)}
Timeframe
{tf}
{String(trend.summary)}
}
{checks.length > 0 && (
Checks
Stack/slope set bias; RSI/MACD agree only.
{checks.map((c, i) =>
e.stopPropagation()} className="card" style={{ width: 520, maxWidth: '100%', maxHeight: '90vh', overflow: 'auto' }}>
Research Spec · {symbol}
{loading ?
Loading Spec…
: (
<>
{isInc ? 'Not Ready — Incomplete until trend cache is fresh. Bias is never invented.'
: 'Spec Ready (V1 trend). Sector flow pending (V2). Own Binance data only.'}
{status}
{pL && {pL}}
{sL && {sL}}
{(isInc || !dup) && {reason}
}Trend
{trendVal ? {trendHint}
}
Sector flow
{sectorVal != null
? {String(sectorVal)}
: Until V2
}
Own Binance data only. No live trading.
)}
Loading…
;
}
if (!filtered.length) {
return
{rows.length ? 'No signals match the current filters.' : 'No open signals in the ledger.'}
;
}
const sorted = sortLedgerRows(filtered, sortKey, sortDir);
const th = { textAlign: 'left', fontSize: 9.5, color: 'var(--text-4)', letterSpacing: '0.09em',
textTransform: 'uppercase', padding: '0 8px 7px', fontWeight: 500 };
const thSort = { ...th, cursor: 'pointer', userSelect: 'none', whiteSpace: 'nowrap' };
const td = { padding: '7px 8px', borderTop: '1px solid var(--border-soft)', fontSize: 11.5 };
const onSort = (key) => {
if (sortKey === key) setSortDir(d => d === 'asc' ? 'desc' : 'asc');
else { setSortKey(key); setSortDir(LEDGER_SORT_DEFAULT_DIR[key] || 'asc'); }
};
const sortMark = (key) => {
if (sortKey !== key) return ↕;
return {sortDir === 'asc' ? '▲' : '▼'};
};
const SortTh = ({ col, children, title }) => (
| targets | price | accounts | |||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
{r.side} |
{POS_STATE_LABEL[r.state] || r.state}
{r.state === 'PARTIAL' && r.remaining_pct != null && (
{' · ' + Math.round(r.remaining_pct) + '% left'}
)}
|
{r.first_post_id && onViewMessage ? (
onViewMessage(r.first_post_id)} style={{ cursor: 'pointer' }}
title="View the message that opened this signal">
|
{r.sl_qualifier
?
{(r.sl_qualifier === 'in_profit' ? (r.side === 'long' ? '> ' : '< ') : '≈ ')
+ (r.entry_price != null ? fmtNum(r.entry_price)
: r.reference_price != null ? fmtNum(r.reference_price) : 'entry')}
{r.sl != null && (
{fmtNum(r.sl)}
)}
: r.sl == null
? blocked · no SL
: fmtNum(r.sl)}
|
{(r.tps || []).map(fmtNum).join(' · ') || '—'}
|
{ledgerEntryRefLabel(r)}
|
{r.paper && r.paper.mark != null
? |
{unmatched
? Not on your account
: positions.length ? positions.map(p => (
{p.account_label}{' '}
{POS_OPEN.includes(p.state)
?
{`${fmtNum(p.filled_qty)} @ ${fmtNum(p.avg_fill)}`}
{p.unrealized_pnl != null && (
= 0 ? 'var(--bull)' : 'var(--bear)' }}>
{(Number(p.unrealized_pnl) >= 0 ? '+' : '') + fmtUsd(p.unrealized_pnl)}
)}
: {POS_STATE_LABEL[p.state] || p.state.toLowerCase()}}
{isAdmin && (p.edits || []).slice(0, 3).map(e => (
)) : none}
{e.field} {fmtNum(e.old_value)} → {fmtNum(e.new_value)} (manual, {agoFrom(e.at)})
))}
|
{unmatched ? — : orphan ? ⚠ {open.length} held — needs close : drift ? (isAdmin ? ⚠ ledger-only · no position : no position) : {open.length} held} | {agoFrom(r.updated_at)} |
{!unmatched && open.map(p => (
{onEditPosition && (p.state === 'OPEN' || p.state === 'PARTIAL') && (
)}
))}
{onViewChart && r.symbol_tradable !== 0 && (
)}
{onAsk && (
)}
{!unmatched && !orphan && drift && r.symbol_tradable !== 0 && onResend && (
)}
{editRecord && (
)}
{onReanalyze && (r.sl == null || !(r.tps && r.tps.length) || r.entry_price == null) && (
)}
|
| Exit | Size | Price | R | When |
|---|---|---|---|---|
| {EXIT_KIND_LABEL[e.kind] || e.kind} {e.assumed && ~} {e.price_source === 'target_level' && @target} | {Math.round(e.size * 100)}% | {fmtNum(e.price)} | = 0 ? 'var(--bull)' : 'var(--bear)' }}>{signedR(e.r)} | {e.at ? fmtStamp(e.at) : '—'} |
| Whole trade | 100% | = 0 ? 'var(--bull)' : 'var(--bear)' }}>{signedR(total)} |
Loading…
;
}
if (!rows.length) {
return No closed signals yet.
;
}
const symbols = [...new Set(rows.map(r => r.symbol).filter(Boolean))].sort();
const filtered = rows.filter(r => {
if (symbolFilter !== 'all' && r.symbol !== symbolFilter) return false;
if (sideFilter !== 'all' && r.side !== sideFilter) return false;
if (rFilter === 'positive' && !(r.r_multiple_a > 0)) return false;
if (rFilter === 'negative' && !(r.r_multiple_a < 0)) return false;
if (rFilter === 'unscored' && r.r_multiple_a != null) return false;
return true;
});
const sorted = sortHistoryRows(filtered, sortKey, sortDir);
const totalPages = Math.max(1, Math.ceil(sorted.length / HISTORY_PAGE_SIZE));
const safePage = Math.min(page, totalPages - 1);
const paged = sorted.slice(safePage * HISTORY_PAGE_SIZE, (safePage + 1) * HISTORY_PAGE_SIZE);
const selectStyle = {
padding: '3px 8px', borderRadius: 6, fontSize: 11, cursor: 'pointer',
fontFamily: 'var(--font-sans)', background: 'var(--bg-elev)',
border: '1px solid var(--border-soft)', color: 'var(--text)',
};
const th = { textAlign: 'left', fontSize: 9.5, color: 'var(--text-4)', letterSpacing: '0.09em',
textTransform: 'uppercase', padding: '0 8px 7px', fontWeight: 500 };
const thSort = { ...th, cursor: 'pointer', userSelect: 'none', whiteSpace: 'nowrap' };
const td = { padding: '7px 8px', borderTop: '1px solid var(--border-soft)', fontSize: 11.5 };
const onSort = (key) => {
if (sortKey === key) setSortDir(d => d === 'asc' ? 'desc' : 'asc');
else { setSortKey(key); setSortDir(HISTORY_SORT_DEFAULT_DIR[key] || 'asc'); }
setPage(0);
};
const sortMark = (key) => {
if (sortKey !== key) return ↕;
return {sortDir === 'asc' ? '▲' : '▼'};
};
const SortTh = ({ col, children, title }) => (
{sorted.length} / {rows.length} trades
| entry | exit | now | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| {r.side} | {stateLabel} {r.state === 'EXPIRED' && ( ? )} | {outLabel} | {fmtNum(historyEntryPrice(r))} | {openPos ? ⚠ still open : (r.exits && r.exits.length > 1 && !(r.positions || []).some(p => p.avg_close != null)) ? {fmtNum(r.avg_exit_price)} avg of {r.exits.length} exits : fmtNum(historyExitPrice(r))} | {fmtNum(r.current_price)} | = 0 ? 'var(--bull)' : 'var(--bear)' }} title={r.result_basis === 'ledger_close' ? 'R of the whole trade at the prices it was exited at, against the stop it started with' + (r.exits && r.exits.length > 1 ? ` (${r.exits.length} exits — open the row for each).` : '.') + (r.sim_r_multiple_a != null ? ` The simulated first-target score is ${signedR(r.sim_r_multiple_a)}.` : '') : 'Simulated: entry to the first target or the original stop, whichever price reached first.'}> {r.r_multiple_a == null ? '—' : signedR(r.r_multiple_a)} | {fmtStamp(r.created_at)} | {['LIVE', 'PARTIAL', 'WATCHING'].includes(r.state) ? '—' : fmtStamp(r.updated_at)} | {viewMode !== 'admin' && ({unmatched ? Not on your account : Applied} | )}{onViewTimeline && ( )} {onDelete && !['LIVE', 'PARTIAL', 'WATCHING'].includes(r.state) && ( )} |
{safePage + 1} / {totalPages}
)}
{label}
{value}
{subtitle && {subtitle}
}
{err}
;
if (loading || !data) return Loading report…
;
const { summary: s, trades } = data;
if (!s.n) return No resolved trades in this period.
;
const th = { textAlign: 'left', fontSize: 9.5, color: 'var(--text-4)', letterSpacing: '0.09em',
textTransform: 'uppercase', padding: '0 8px 7px', fontWeight: 500 };
const td = { padding: '7px 8px', borderTop: '1px solid var(--border-soft)', fontSize: 11.5 };
return (
| symbol | side | stated | market at signal | stated → market | entry | our fill | fill vs stated | exit | % | R | fees R | outcome | opened | closed |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| {t.symbol} | {t.side} | {fmtNum(t.stated_price)} | {fmtNum(t.market_at_signal)} | {reportAdversePct(t.stated_vs_market_pct)} | {fmtNum(t.entry_price)} | {fmtNum(t.our_fill)} | {reportAdversePct(t.fill_vs_stated_pct)} | {fmtNum(t.exit_price)} | {t.pct_return != null ? signedPct(t.pct_return) : '—'} {t.real_pnl != null && ({fmtUsd(t.real_pnl)})} | {t.net_r != null ? signedR(t.net_r) : '—'} | {t.fees_r != null ? t.fees_r.toFixed(4) : '—'} | {(() => { const [label, color] = REPORT_OUTCOME_CHIP[t.outcome] || [t.outcome || '—', 'var(--text-4)']; return {label}; })()} | {fmtStamp(t.opened_at)} | {fmtStamp(t.closed_at)} |
{open && (
);
}
// A long message is clamped so a card stays scannable, but never cut off for good:
// "Show more" expands it in place.
function ExpandableText({ text, limit = 640, style }) {
const [open, setOpen] = useS(false);
const long = text.length > limit;
return (
{checks.map((c, i) => (
)}
{c.pass ? '✓' : '✕'}
{c.check}
{c.reason_code}
{c.detail && {String(c.detail).slice(0, 90)}}
))}
{!long || open ? text : text.slice(0, limit) + '…'}
{long && (
)}
{s.intent}
{s.symbol && {s.symbol}{s.side ? ' ' + s.side : ''}}
{s.extraction && s.extraction.market_price_at_post != null && (
@ {fmtNum(s.extraction.market_price_at_post)}
)}
{!s.symbol_tradable && s.symbol && (
not tradable
)}
{s.signal_id != null && onJumpToLedger && (
)}
{onAddToLedger && (
)}
{s.confidence != null && (
conf {Number(s.confidence).toFixed(2)}
)}
{s.action || '—'}
{reasonLabel(s.reason_code)}
{s.evidence_quote && (
“{String(s.evidence_quote).slice(0, 160)}”
)}
setLightbox(false)} style={{
position: 'fixed', inset: 0, background: 'rgba(0,0,0,0.88)', zIndex: 60,
display: 'flex', alignItems: 'center', justifyContent: 'center', padding: 30,
}}>
e.stopPropagation()}
style={{ maxWidth: '92vw', maxHeight: '92vh', borderRadius: 4, display: 'block', cursor: 'default' }} />
{n > 1 && (
<>
{i + 1} / {n}
)}
)}
);
}
function MessageActions({ text }) {
const [copied, setCopied] = useS(false);
const [translation, setTranslation] = useS(null);
const [translating, setTranslating] = useS(false);
const [translateErr, setTranslateErr] = useS(null);
const btnStyle = {
padding: '2px 7px', borderRadius: 5, cursor: 'pointer', fontSize: 9.5,
background: 'transparent', border: '1px solid var(--border-soft)', color: 'var(--text-3)',
fontFamily: 'var(--font-sans)', display: 'inline-flex', alignItems: 'center', gap: 3,
};
const onCopy = async () => {
try {
await navigator.clipboard.writeText(text);
setCopied(true);
setTimeout(() => setCopied(false), 1500);
} catch (_) {}
};
const onWhatsApp = () => {
window.open('https://wa.me/?text=' + encodeURIComponent(text), '_blank', 'noopener');
};
const onTranslate = async () => {
if (translation) { setTranslation(null); return; } // toggle back to original
setTranslating(true);
setTranslateErr(null);
try {
setTranslation(await translateToPT(text));
} catch (e) {
setTranslateErr('Translation failed');
}
setTranslating(false);
};
return (
{translation && (
{translateErr &&
);
}
function feedFilterQuery(symbol, query) {
const qs = new URLSearchParams();
if (symbol) qs.set('symbol', symbol);
if (query) qs.set('q', query);
return qs.toString();
}
// Earlier edit versions of a message, collapsed under its latest card. Each keeps its own
// text and sub_events, so what the trader changed — and which version was added to the
// ledger — stays visible without the message showing up once per edit.
function EditVersions({ versions, onJumpToLedger, onAddToLedger }) {
const [open, setOpen] = useS(false);
if (!versions || !versions.length) return null;
return (
Portuguese
{translation}
)}
{translateErr}
}
{open && (
);
}
function SignalFeed({ onJumpToLedger, onAddToLedger, strategyId, symbolFilter, queryFilter, readOnly }) {
const [posts, setPosts] = useS([]);
const [next, setNext] = useS(null);
const [loading, setLoading] = useS(true);
const [rerunBusy, setRerunBusy] = useS(null); // post id being re-run
const [rerunNote, setRerunNote] = useS({}); // post id -> { ok, text } from the last re-run
// Actionable posts, plus forwards. Pure commentary lives in its own column beside this
// one, and showing the same post in both just makes the operator read twice. A forwarded
// message is shown here (not in the commentary column) so it is never invisible: some
// channels, like Dr. Profit's Signals Only, are made of forwards. The pipeline still does
// not trade on them; they carry a "Forwarded message" label.
const NOOP = ['STATUS_COMMENTARY', 'INFO_ONLY', 'NOISE_ANNOUNCEMENT',
'CONDITIONAL_WATCH', 'AMBIGUOUS'];
const load = useC(async (before) => {
const filt = feedFilterQuery(symbolFilter, queryFilter);
const q = (before ? `?before_id=${before}&limit=25` : '?limit=25') + (filt ? '&' + filt : '');
const r = await fetch(sigWithStrategy('/api/signals/feed' + q, strategyId)).then(x => x.json()).catch(() => null);
if (r && r.ok) {
const actionable = r.data.filter(p => (p.sub_events || [])
.some(s => NOOP.indexOf(s.intent) === -1));
setPosts(p => before ? p.concat(actionable) : actionable);
setNext(r.next_before_id);
}
setLoading(false);
}, [strategyId, symbolFilter, queryFilter]);
useE(() => { setLoading(true); load(); const id = setInterval(() => load(), 60000); return () => clearInterval(id); }, [load]);
// A message that failed before a fix can be sent back through the normal pipeline, as if it had
// just arrived (checked against the market now). Only posts that produced no signal qualify.
const FAILED = ['skipped', 'needs_approval', 'alert_user'];
// A failed message, or a chart post nothing was made of (called commentary: the chart itself may
// be the setup, and the pipeline now reads it).
const SOFT = ['STATUS_COMMENTARY', 'INFO_ONLY', 'AMBIGUOUS', 'CONDITIONAL_WATCH', 'NOISE_ANNOUNCEMENT'];
const canRerun = (p) => {
const subs = p.sub_events || [];
if (subs.some(x => x.signal_id != null)) return false;
return subs.some(x => FAILED.indexOf(x.action) !== -1)
|| (!!(p.media_urls && p.media_urls.length) && subs.length > 0 && subs.every(x => SOFT.indexOf(x.intent) !== -1));
};
const rerun = async (p) => {
const mins = Math.max(0, Math.round((Date.now() / 1000 - (p.date_unixtime || 0)) / 60));
const age = mins < 120 ? `${mins} min` : `${Math.round(mins / 60)} h`;
if (!window.confirm(`Re-run this message through the pipeline as if it had just arrived?\n\n`
+ `It is ${age} old and is checked against the market now, so a setup that has already played out is still refused. `
+ `This replaces the earlier verdict for this message.`)) return;
setRerunBusy(p.id);
const r = await fetch(`/api/signals/feed/post/${p.id}/reprocess`, { method: 'POST' })
.then(x => x.json()).catch(e => ({ ok: false, reason: 'REQUEST_FAILED', detail: String(e.message || e) }));
setRerunBusy(null);
const text = r.ok
? (r.results || []).map(x => `${x.intent} ${x.symbol || '-'} → ${x.action}${x.reason ? ` (${x.reason})` : ''}`).join(' · ') || 'processed'
: `${r.reason || 'failed'}: ${r.detail || r.error || ''}`;
setRerunNote(n => ({ ...n, [p.id]: { ok: !!r.ok, text } }));
load();
};
return (
{versions.map(v => (
)}
version {v.edit_version}{v.processed_at ? ' · ' + String(v.processed_at).replace('T', ' ').slice(0, 16) : ''}
{v.text
? no text in this version
}
{(v.sub_events || []).map(s =>
Signal feed
{posts.length} shown
{loading &&
Loading…
}
{!loading && !posts.length && (
{(symbolFilter || queryFilter)
? 'No actionable messages match this filter.'
: 'Nothing processed yet — the worker may still be starting.'}
)}
{posts.map(p => (
#{p.primary_message_id}
{p.forwarded_from && forwarded}
{(p.versions || []).length > 0 && edited}
{!readOnly && canRerun(p) && (
)}
{new Date((p.date_unixtime || 0) * 1000).toISOString().replace('T', ' ').replace(/\..+/, '')}
{rerunNote[p.id] && (
Re-run: {rerunNote[p.id].text}
)}
{p.text && (
{(p.sub_events || []).map(s =>
Trader commentary
non-trade posts
{loading &&
Loading…
}
{!loading && !posts.length && (
{(symbolFilter || queryFilter) ? 'No commentary matches this filter.' : 'No commentary posts in this range.'}
)}
{posts.map(p => (
#{p.primary_message_id}
{(p.sub_events || []).slice(0, 2).map(s => (
{s.intent}
))}
{new Date((p.date_unixtime || 0) * 1000).toISOString().replace('T', ' ').slice(0, 16)}
{p.text && (
{/* filters in one row above the table */}
{!rows.length &&
);
}
// ── page ───────────────────────────────────────────────────────────────────
const POLICY_LABEL = {
A: ['A · bracket', 'Initial stop, everything out at target 1, stop never moved. The candidate live policy.'],
B: ['B · trader-managed', 'Equal slices over his targets, stop to breakeven after the first. How he manages it.'],
D: ['D · equal slices', 'Up to 4 equal slices at his targets, original stop never moved.'],
};
function Scorecard({ strategyId, viewMode }) {
const [sc, setSc] = useS(null);
const [scope, setScope] = useS('forward');
useE(() => {
const url = viewMode === 'admin'
? sigWithStrategy('/api/signals/scorecard', strategyId)
: meStrategyUrl(strategyId, 'scorecard');
const load = () => fetch(url).then(r => r.json())
.then(j => { if (j && j.ok) setSc(j.data); }).catch(() => {});
load();
const id = setInterval(load, 60000);
return () => clearInterval(id);
}, [strategyId, viewMode]);
if (!sc) return
set('symbol', e.target.value)} style={{ ...sel, width: 90 }} />
{(f.symbol || f.intent || f.action || f.reason) && (
)}
| {h} | ))}|||||
|---|---|---|---|---|---|
| {agoFrom(r.at)} | {r.symbol || '—'} | {r.intent} | {r.action} | {reasonLabel(r.reason_code)} |
{(r.accounts || []).map(a => (
{a.account_label}{' '}
{a.action}
))}
|
No decisions match.
}
{next && (
)}
Loading…
;
const g = sc.groups[scope];
const fmtR = v => v == null ? '—' : (v >= 0 ? '+' : '−') + Math.abs(v).toFixed(2) + 'R';
const tone = v => v == null ? 'var(--text-3)' : v > 0 ? 'var(--bull)' : v < 0 ? 'var(--bear)' : 'var(--text-3)';
const cell = { padding: '6px 10px', textAlign: 'right' };
const rowsDef = [];
['A', 'B', 'D'].forEach(p => [['all', 'all signals'], ['eligible', 'eligible only']].forEach(
([k, lab]) => rowsDef.push({ p, k, lab, s: g[p][k] })));
const nForward = g.A.all.n + g.A.all.open;
const rep = Object.entries(sc.trader_reported || {}).sort((a, b) => b[1] - a[1]);
return (
{[['forward', 'Forward record'], ['history', 'History (before rules-v1)']].map(([id, label]) => (
))}
{scope === 'forward' && nForward === 0 ? (
No signals since the rules were frozen{sc.forward_since ? ' (' + sc.forward_since.slice(0, 16).replace('T', ' ') + ' UTC)' : ''}.
The first one will appear here once it has resolved.
) : (
| Policy | Closed | Open | Win rate | Avg R | Total R | Max drawdown |
|---|---|---|---|---|---|---|
| {POLICY_LABEL[p][0]} · {lab} | {s.n} | {s.open} | {s.n ? Math.round(100 * s.wins / s.n) + '%' : '—'} | {fmtR(s.avg_r)} | {fmtR(s.total_r)} | {s.max_drawdown_r == null ? '—' : s.max_drawdown_r.toFixed(2) + 'R'} |
R after taker fees, measured against the risk at our fill. Outcomes come from Bybit candles, not
from what he says; a candle touching both stop and target counts as the stop.
{g.A.all.n < 25 && ' With fewer than ~25 closed trades this can only rule out disasters, not prove an edge.'}
{rep.length > 0 && scope === 'history' && (
· His own account of these: {rep.map(([k, v]) => k.replace('trader_', '') + ' ' + v).join(', ')}.
)}
e.stopPropagation()} className="card" style={{ width: 520, maxWidth: '100%', maxHeight: '80vh', display: 'flex', flexDirection: 'column' }}>
Originating message
{state.loading &&
Loading…
}
{state.error && {state.error}
}
{state.post && (
#{state.post.primary_message_id}
{new Date((state.post.date_unixtime || 0) * 1000).toISOString().replace('T', ' ').replace(/\..+/, '')}
{state.post.text && (
{state.post.text}
)}
{(state.post.sub_events || []).map(s => (
{ onClose(); onJumpToLedger(id); }}
onAddToLedger={onAddToLedger ? se => { onClose(); onAddToLedger(se); } : null} />
))}
e.stopPropagation()} className="card" style={{ width: 560, maxWidth: '100%', maxHeight: '84vh', display: 'flex', flexDirection: 'column' }}>
Signal timeline{sig ? ` · ${sig.symbol} ${sig.side}` : ''}
{state.loading &&
)}
Loading…
}
{state.error && {state.error}
}
{!state.loading && !state.error && (
{posts.length} message{posts.length === 1 ? '' : 's'} linked to this signal.
{!posts.length && (
No message is linked to this signal.
)}
{posts.map((p, i) => (
{ending && (
{i < posts.length - 1 && }
#{p.primary_message_id}
{new Date((p.date_unixtime || 0) * 1000).toISOString().replace('T', ' ').replace(/\..+/, '')}
{p.text && (
{p.text}
)}
{(p.sub_events || []).map(s => (
{ onClose(); onJumpToLedger(id); }) : null}
onAddToLedger={onAddToLedger ? (se => { onClose(); onAddToLedger(se); }) : null} />
))}
{ending.text}
)}
e.stopPropagation()} className="card" style={{ width: 920, maxWidth: '100%', maxHeight: '88vh', display: 'flex', flexDirection: 'column' }}>
{sig ? `${sig.symbol} ${sig.side} · price vs. levels` : 'Price chart'}
{state.loading &&
)}
{!state.loading && !state.error && (
Loading…
}
{state.error && (
{state.error}
{CHART_INTERVALS.map(([id, label]) => (
))}
{state.candles && state.candles.length
? No candle history for this symbol/timeframe.
}
Current {fmtNum(mark)}
{sig && sig.market_price_at_post != null && (
· at post {fmtNum(sig.market_price_at_post)}
)}
{sig && sig.entry_price != null && sig.reference_price != null
&& Number(sig.entry_price) !== Number(sig.reference_price) && (() => {
const gapPct = ((Number(sig.entry_price) - Number(sig.reference_price)) / Number(sig.reference_price)) * 100;
return (
Entry gap = 0 ? 'var(--bull)' : 'var(--bear)' }}>
{signedPct(gapPct)}
· our {fmtNum(sig.entry_price)} vs.
his {fmtNum(sig.reference_price)}
);
})()}
{levels.map((lv, i) => {
const dist = mark ? ((lv.price - mark) / mark) * 100 : null;
return (
{lv.label}
{fmtNum(lv.price)}
= 0 ? 'var(--bull)' : 'var(--bear)' }}>
{dist == null ? '—' : signedPct(dist)}
);
})}
{!levels.length && (
No entry/SL/targets recorded for this signal.
)}
% is each level's distance from the current price — a positive number
means price has to rise to reach it, negative means it has to fall.
{[['open', isAdmin ? 'Ledger ↔ accounts' : 'Active trades'], ['history', 'History'], ['stories', 'Trade stories'], ['report', 'Report']].map(([id, label]) => (
))}
{canAsk && (ledgerTab === 'history' ? (
) : (
))}
{ledgerTab === 'open' ? (
{marks.at && (
{marks.stale ? '⚠ prices ' : 'prices '}{agoFrom(new Date(marks.at).toISOString())}
)}
{ledger ? ledger.length : '…'} open
) : ledgerTab === 'history' ? (
{history ? history.length : '…'} shown
) : null}
{ledgerTab === 'open' ? (
{ setCloseTarget(t); setCloseErr(null); }}
onEditPosition={setEditPosTarget}
onViewMessage={canRead ? viewMessage : null} onEdit={setEditTarget}
onResend={t => { setResendTarget(t); setResendErr(null); setResendResult(null); }}
onReanalyze={isAdmin ? t => { setReanalyzeTarget(t); setReanalyzeErr(null); setReanalyzeResult(null); } : null}
onViewChart={isAdmin ? setChartSignalId : null}
viewMode={viewMode} onOpenSpec={setSpecSymbol} userRole={userRole} onAsk={askAboutTrade} />
) : ledgerTab === 'history' ? (<>
{tradeFilter && (
Showing the {history ? history.length : tradeFilter.ids.length} trade{(history ? history.length : tradeFilter.ids.length) === 1 ? '' : 's'} behind {tradeFilter.label}
{history && history.length < tradeFilter.ids.length && (
({tradeFilter.ids.length - history.length} no longer on file)
)}
)}
setScorecardOpen(v => !v)}>
Scorecard · how signals ended
{scorecardOpen ? '▲ hide' : '▼ show'}
{scorecardOpen &&
Search this trader's messages
setFeedQuery(e.target.value)} placeholder="Search text…" style={{
padding: '5px 9px', borderRadius: 6, fontSize: 11.5, flex: 1, minWidth: 160,
fontFamily: 'var(--font-sans)', background: 'var(--bg-elev)',
border: '1px solid var(--border-soft)', color: 'var(--text)',
}} />
{(feedSymbol || feedQuery) && (
)}
Decision audit