('react-router-dom')
+ return {
+ ...actual,
+ useNavigate: () => navigateMock,
+ }
+})
+
+function Wrapper({ children }: { children: React.ReactNode }) {
+ const client = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+ return (
+
+ {children}
+
+ )
+}
+
+describe('WatchlistTable', () => {
+ it('renders scored tickers using score field', () => {
+ render(
+ ,
+ { wrapper: Wrapper },
+ )
+
+ expect(screen.getByText('AAPL')).toBeInTheDocument()
+ expect(screen.getByText('0.82')).toBeInTheDocument()
+ expect(screen.getByText('gap_up')).toBeInTheDocument()
+ })
+
+ it('renders 0.00 when score is undefined (null-guard)', () => {
+ render(
+ ,
+ { wrapper: Wrapper },
+ )
+
+ expect(screen.getByText('MSFT')).toBeInTheDocument()
+ expect(screen.getByText('0.00')).toBeInTheDocument()
+ })
+
+ it('navigates to discovery with selected ticker when row clicked', () => {
+ render(
+ ,
+ { wrapper: Wrapper },
+ )
+
+ fireEvent.click(screen.getByText('TSLA'))
+ expect(navigateMock).toHaveBeenCalledWith('/discovery?tickers=TSLA')
+ })
+})
diff --git a/web/src/components/universe/watchlist-table.tsx b/web/src/components/universe/watchlist-table.tsx
index 8f09584b..d75de9cc 100644
--- a/web/src/components/universe/watchlist-table.tsx
+++ b/web/src/components/universe/watchlist-table.tsx
@@ -7,9 +7,9 @@ interface WatchlistTableProps {
tickers: ScoredTicker[]
}
-function scoreBadgeVariant(score: number) {
- if (score > 0.7) return 'success' as const
- if (score > 0.4) return 'warning' as const
+function scoreBadgeVariant(score: number | undefined) {
+ if ((score ?? 0) > 0.7) return 'success' as const
+ if ((score ?? 0) > 0.4) return 'warning' as const
return 'destructive' as const
}
@@ -45,8 +45,8 @@ export function WatchlistTable({ tickers }: WatchlistTableProps) {
>
| {t.ticker} |
-
- {(t.score ?? t.watch_score ?? 0).toFixed(2)}
+
+ {(t.score ?? 0).toFixed(2)}
|
{
beforeEach(() => {
- vi.useFakeTimers()
MockWebSocket.instances = []
vi.stubGlobal('WebSocket', MockWebSocket)
})
afterEach(() => {
cleanup()
- vi.useRealTimers()
vi.unstubAllGlobals()
})
- it('renders all dashboard sections', async () => {
+ it('renders dashboard activity and recent runs from the API', async () => {
const fetchMock = vi.fn((input: RequestInfo | URL) => {
const url = typeof input === 'string' ? input : input.toString()
@@ -65,6 +63,51 @@ describe('DashboardPage', () => {
})
}
+ if (url.includes('/api/v1/runs')) {
+ return Promise.resolve({
+ ok: true,
+ status: 200,
+ json: async () => ({
+ data: [
+ {
+ id: 'run-1',
+ strategy_id: 'strategy-1',
+ ticker: 'AAPL',
+ trade_date: '2026-04-22T00:00:00Z',
+ status: 'completed',
+ signal: 'buy',
+ started_at: '2026-04-22T00:00:00Z',
+ completed_at: '2026-04-22T00:03:00Z',
+ },
+ ],
+ limit: 10,
+ offset: 0,
+ }),
+ })
+ }
+
+ if (url.includes('/api/v1/events')) {
+ return Promise.resolve({
+ ok: true,
+ status: 200,
+ json: async () => ({
+ data: [
+ {
+ id: 'evt-1',
+ pipeline_run_id: 'run-1',
+ strategy_id: 'strategy-1',
+ event_kind: 'pipeline_started',
+ title: 'Pipeline started',
+ summary: 'AAPL run kicked off',
+ created_at: '2026-04-22T00:00:00Z',
+ },
+ ],
+ limit: 20,
+ offset: 0,
+ }),
+ })
+ }
+
if (url.includes('strateg')) {
return Promise.resolve({
ok: true,
@@ -93,8 +136,11 @@ describe('DashboardPage', () => {
render(, { wrapper: Wrapper })
- expect(screen.getByTestId('dashboard-page')).toBeInTheDocument()
- expect(screen.getByTestId('activity-feed')).toBeInTheDocument()
+ expect(await screen.findByTestId('dashboard-page')).toBeInTheDocument()
+ expect(await screen.findByText('AAPL run kicked off')).toBeInTheDocument()
+ expect(screen.getAllByText('Pipeline started').length).toBeGreaterThan(0)
+ expect(await screen.findByText('Recent runs')).toBeInTheDocument()
+ expect(await screen.findByText('AAPL')).toBeInTheDocument()
})
it('renders when the active strategies data array is null', async () => {
diff --git a/web/src/pages/dashboard-page.tsx b/web/src/pages/dashboard-page.tsx
index b7bf9dd1..81fa025e 100644
--- a/web/src/pages/dashboard-page.tsx
+++ b/web/src/pages/dashboard-page.tsx
@@ -4,6 +4,7 @@ import { UpcomingEventsWidget } from '@/components/calendar/upcoming-events-widg
import { ActiveStrategies } from '@/components/dashboard/active-strategies'
import { ActivityFeed } from '@/components/dashboard/activity-feed'
import { PortfolioSummary } from '@/components/dashboard/portfolio-summary'
+import { RecentRuns } from '@/components/dashboard/recent-runs'
import { PageHeader } from '@/components/layout/page-header'
import { RiskStatusBar } from '@/components/dashboard/risk-status-bar'
import { Badge } from '@/components/ui/badge'
@@ -34,6 +35,7 @@ export function DashboardPage() {
diff --git a/web/src/pages/glossary-page.test.tsx b/web/src/pages/glossary-page.test.tsx
new file mode 100644
index 00000000..f5036b54
--- /dev/null
+++ b/web/src/pages/glossary-page.test.tsx
@@ -0,0 +1,64 @@
+import { cleanup, fireEvent, render, screen } from '@testing-library/react'
+import { MemoryRouter } from 'react-router-dom'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import { GlossaryPage, GLOSSARY_TERMS } from '@/pages/glossary-page'
+
+function renderPage() {
+ return render(
+
+
+ ,
+ )
+}
+
+describe('GlossaryPage', () => {
+ afterEach(() => {
+ cleanup()
+ })
+
+ it('renders the page heading', () => {
+ renderPage()
+ expect(screen.getByTestId('glossary-page')).toBeInTheDocument()
+ })
+
+ it('renders all terms by default', () => {
+ renderPage()
+ for (const term of GLOSSARY_TERMS) {
+ expect(screen.getByTestId(`glossary-term-${term.slug}`)).toBeInTheDocument()
+ }
+ })
+
+ it('filters terms by search query (term name)', () => {
+ renderPage()
+ const input = screen.getByTestId('glossary-search')
+ fireEvent.change(input, { target: { value: 'kill switch' } })
+
+ expect(screen.getByTestId('glossary-term-kill-switch')).toBeInTheDocument()
+ expect(screen.queryByTestId('glossary-term-backtest')).not.toBeInTheDocument()
+ })
+
+ it('filters terms by definition keyword', () => {
+ renderPage()
+ const input = screen.getByTestId('glossary-search')
+ fireEvent.change(input, { target: { value: 'websocket' } })
+
+ expect(screen.getByTestId('glossary-term-realtime')).toBeInTheDocument()
+ })
+
+ it('shows empty state when no terms match', () => {
+ renderPage()
+ const input = screen.getByTestId('glossary-search')
+ fireEvent.change(input, { target: { value: 'zzznomatchzzz' } })
+
+ expect(screen.getByTestId('glossary-empty')).toBeInTheDocument()
+ })
+
+ it('groups terms alphabetically', () => {
+ renderPage()
+ const headings = screen.getAllByRole('heading', { level: 2 })
+ const letters = headings.map((h) => h.textContent)
+ const sorted = [...letters].sort()
+ expect(letters).toEqual(sorted)
+ })
+})
diff --git a/web/src/pages/glossary-page.tsx b/web/src/pages/glossary-page.tsx
new file mode 100644
index 00000000..d94541eb
--- /dev/null
+++ b/web/src/pages/glossary-page.tsx
@@ -0,0 +1,346 @@
+import { BookOpen, Search } from 'lucide-react'
+import { useMemo, useState } from 'react'
+
+import { PageHeader } from '@/components/layout/page-header'
+import { Badge } from '@/components/ui/badge'
+import { Input } from '@/components/ui/input'
+
+// ---- term data ----
+
+export interface GlossaryTerm {
+ term: string
+ slug: string
+ category: string
+ definition: string
+}
+
+export const GLOSSARY_TERMS: GlossaryTerm[] = [
+ {
+ term: 'AMC',
+ slug: 'amc',
+ category: 'earnings',
+ definition:
+ 'After Market Close — an earnings report released after the trading day ends. Prices may gap at the next open.',
+ },
+ {
+ term: 'Automation',
+ slug: 'automation',
+ category: 'system',
+ definition:
+ 'Scheduled or event-driven workflows that run strategies, send alerts, or perform maintenance tasks without manual intervention.',
+ },
+ {
+ term: 'Backtest',
+ slug: 'backtest',
+ category: 'strategy',
+ definition:
+ 'A simulated test of a strategy against historical price data to evaluate how it would have performed in the past.',
+ },
+ {
+ term: 'BMO',
+ slug: 'bmo',
+ category: 'earnings',
+ definition:
+ 'Before Market Open — an earnings report released before the trading day starts. Prices may gap at the open.',
+ },
+ {
+ term: 'Circuit Breaker',
+ slug: 'circuit-breaker',
+ category: 'risk',
+ definition:
+ 'An automated control that pauses trading when specific risk thresholds are breached, preventing further losses until manually reviewed.',
+ },
+ {
+ term: 'Discovery',
+ slug: 'discovery',
+ category: 'system',
+ definition:
+ 'An AI-powered scan that analyzes the universe of tracked securities and surfaces the most promising opportunities based on configured criteria.',
+ },
+ {
+ term: 'EPS',
+ slug: 'eps',
+ category: 'earnings',
+ definition:
+ "Earnings Per Share — a company's net profit divided by the number of outstanding shares. A key metric for comparing earnings reports against analyst estimates.",
+ },
+ {
+ term: 'Fill Price',
+ slug: 'fill-price',
+ category: 'orders',
+ definition:
+ 'The actual price at which an order was executed, which may differ from the limit or market price requested.',
+ },
+ {
+ term: 'Gap',
+ slug: 'gap',
+ category: 'price',
+ definition:
+ "A price difference between a stock's prior close and the next open, caused by overnight news or earnings releases.",
+ },
+ {
+ term: 'Kill Switch',
+ slug: 'kill-switch',
+ category: 'risk',
+ definition:
+ 'An emergency control that immediately halts all trading activity system-wide. Requires manual reactivation to resume.',
+ },
+ {
+ term: 'Long',
+ slug: 'long',
+ category: 'positions',
+ definition:
+ 'A position that profits when the underlying security rises in price. The standard direction for most equity trades.',
+ },
+ {
+ term: 'Memory',
+ slug: 'memory',
+ category: 'system',
+ definition:
+ 'Stored knowledge — facts, summaries, and decisions — that agents reference across sessions to inform future analysis.',
+ },
+ {
+ term: 'Options Chain',
+ slug: 'options-chain',
+ category: 'options',
+ definition:
+ 'A listing of all available option contracts (calls and puts) for a given security, organized by expiry date and strike price.',
+ },
+ {
+ term: 'P&L',
+ slug: 'pnl',
+ category: 'positions',
+ definition:
+ 'Profit and Loss — the difference between realized or unrealized revenue and the cost of entering a position. Displayed as both a dollar amount and percentage.',
+ },
+ {
+ term: 'Paper Trading',
+ slug: 'paper-trading',
+ category: 'strategy',
+ definition:
+ 'Simulated trading with no real money at risk. Used to validate strategy behavior before live deployment.',
+ },
+ {
+ term: 'Pipeline Run',
+ slug: 'pipeline-run',
+ category: 'system',
+ definition:
+ "A single execution of a strategy's analysis pipeline, encompassing all agent phases from data ingestion through final signal generation.",
+ },
+ {
+ term: 'Position',
+ slug: 'position',
+ category: 'positions',
+ definition:
+ 'An open trade holding shares or contracts. Shows current price, unrealized P&L, and stop/take-profit levels.',
+ },
+ {
+ term: 'Realtime',
+ slug: 'realtime',
+ category: 'system',
+ definition:
+ 'A live event feed that streams pipeline runs and agent activity as they happen via WebSocket, with conversation context for each event.',
+ },
+ {
+ term: 'Reliability',
+ slug: 'reliability',
+ category: 'system',
+ definition:
+ 'System health metrics tracking uptime, latency percentiles, and error rates across pipeline components.',
+ },
+ {
+ term: 'SEC Filing',
+ slug: 'sec-filing',
+ category: 'fundamentals',
+ definition:
+ 'Documents required by the Securities and Exchange Commission, including 10-K annual reports, 10-Q quarterly reports, and 8-K material event disclosures. Can be analyzed by the AI pipeline for trading signals.',
+ },
+ {
+ term: 'Sentiment',
+ slug: 'sentiment',
+ category: 'signals',
+ definition:
+ 'An analyst assessment of whether a signal or filing is bullish (positive), bearish (negative), or neutral. Used to classify pipeline outputs.',
+ },
+ {
+ term: 'Short',
+ slug: 'short',
+ category: 'positions',
+ definition:
+ 'A position that profits when the underlying security falls in price. Involves borrowing shares to sell, then buying them back at a lower price.',
+ },
+ {
+ term: 'Signal',
+ slug: 'signal',
+ category: 'signals',
+ definition:
+ 'A trading recommendation generated at the end of a pipeline run: buy, sell, or hold. Accompanied by confidence score and agent reasoning.',
+ },
+ {
+ term: 'Stop Loss',
+ slug: 'stop-loss',
+ category: 'risk',
+ definition:
+ 'A price level at which a losing position is automatically closed to cap downside. Set per-position based on strategy risk parameters.',
+ },
+ {
+ term: 'Strategy',
+ slug: 'strategy',
+ category: 'strategy',
+ definition:
+ 'A configured set of agents, tickers, schedule, and risk parameters that define how the system analyzes and trades a security.',
+ },
+ {
+ term: 'Take Profit',
+ slug: 'take-profit',
+ category: 'risk',
+ definition:
+ 'A price level at which a profitable position is automatically closed to lock in gains. Works alongside stop loss for symmetric risk management.',
+ },
+ {
+ term: 'Ticker',
+ slug: 'ticker',
+ category: 'price',
+ definition:
+ 'A unique symbol identifying a publicly traded security (e.g., AAPL for Apple Inc.). Used across the system to reference stocks, ETFs, and other instruments.',
+ },
+ {
+ term: 'Universe',
+ slug: 'universe',
+ category: 'system',
+ definition:
+ 'The full set of securities tracked and scored by the system. Securities are ranked by watch score to surface the most relevant candidates.',
+ },
+ {
+ term: 'Watch Score',
+ slug: 'watch-score',
+ category: 'signals',
+ definition:
+ 'A composite ranking score indicating how much attention a ticker deserves. Higher scores reflect stronger technical and fundamental signals.',
+ },
+ {
+ term: 'Watchlist',
+ slug: 'watchlist',
+ category: 'system',
+ definition:
+ 'The active subset of the universe currently under close monitoring. Populated by the Discovery scan and scored tickers above configured thresholds.',
+ },
+]
+
+// ---- category labels ----
+
+const CATEGORY_LABELS: Record = {
+ earnings: 'Earnings',
+ fundamentals: 'Fundamentals',
+ options: 'Options',
+ orders: 'Orders',
+ positions: 'Positions',
+ price: 'Price',
+ risk: 'Risk',
+ signals: 'Signals',
+ strategy: 'Strategy',
+ system: 'System',
+}
+
+// ---- component ----
+
+export function GlossaryPage() {
+ const [query, setQuery] = useState('')
+
+ const filtered = useMemo(() => {
+ const q = query.toLowerCase().trim()
+ if (!q) return GLOSSARY_TERMS
+ return GLOSSARY_TERMS.filter(
+ (t) =>
+ t.term.toLowerCase().includes(q) ||
+ t.definition.toLowerCase().includes(q) ||
+ t.category.toLowerCase().includes(q),
+ )
+ }, [query])
+
+ // group by first letter
+ const groups = useMemo(() => {
+ const map = new Map()
+ for (const term of filtered) {
+ const letter = term.term[0].toUpperCase()
+ if (!map.has(letter)) map.set(letter, [])
+ map.get(letter)!.push(term)
+ }
+ return Array.from(map.entries()).sort(([a], [b]) => a.localeCompare(b))
+ }, [filtered])
+
+ return (
+
+
+
+ {/* Search */}
+
+
+ setQuery(e.target.value)}
+ placeholder="Filter terms…"
+ className="pl-8 text-sm"
+ data-testid="glossary-search"
+ />
+
+
+ {/* Results */}
+ {groups.length === 0 ? (
+
+ No terms match "{query}".
+
+ ) : (
+
+ {groups.map(([letter, terms]) => (
+
+
+ {letter}
+
+
+ {terms.map((t) => (
+
+
+
+
+ {CATEGORY_LABELS[t.category] ?? t.category}
+
+
+
+ {t.definition}
+
+
+ ))}
+
+ ))}
+
+ )}
+
+ {/* Footer with BookOpen icon */}
+
+
+ {GLOSSARY_TERMS.length} terms defined
+
+
= {
pending: 'default',
@@ -37,6 +37,35 @@ function formatDate(dateStr?: string) {
})
}
+function getOptionalStringField(record: Record, key: string): string | undefined {
+ const value = record[key]
+ return typeof value === 'string' && value.length > 0 ? value : undefined
+}
+
+function getOptionalNumberField(record: Record, key: string): number | undefined {
+ const value = record[key]
+ return typeof value === 'number' ? value : undefined
+}
+
+function getOrderOptionFields(order: Order): {
+ optionType?: string
+ underlyingTicker?: string
+ strike?: number
+ expiry?: string
+ contractMultiplier?: number
+ positionIntent?: string
+} {
+ const record = order as unknown as Record
+ return {
+ optionType: getOptionalStringField(record, 'option_type'),
+ underlyingTicker: getOptionalStringField(record, 'underlying_ticker') ?? getOptionalStringField(record, 'underlying'),
+ strike: getOptionalNumberField(record, 'strike'),
+ expiry: getOptionalStringField(record, 'expiry'),
+ contractMultiplier: getOptionalNumberField(record, 'contract_multiplier'),
+ positionIntent: getOptionalStringField(record, 'position_intent'),
+ }
+}
+
export function OrderDetailPage() {
const { id } = useParams<{ id: string }>()
@@ -77,6 +106,7 @@ export function OrderDetailPage() {
}
const order = data.order
+ const optionFields = getOrderOptionFields(order)
return (
@@ -181,7 +211,7 @@ export function OrderDetailPage() {
)}
- {(order as Record ).option_type && (
+ {optionFields.optionType && (
Options info
@@ -189,38 +219,38 @@ export function OrderDetailPage() {
- {(order as Record).underlying && (
+ {optionFields.underlyingTicker && (
- Underlying
- - {String((order as Record).underlying)}
+ - {optionFields.underlyingTicker}
)}
- Option type
- - {String((order as Record).option_type)}
+ - {optionFields.optionType}
- {(order as Record).strike != null && (
+ {optionFields.strike != null && (
- Strike
- - ${Number((order as Record).strike).toFixed(2)}
+ - ${optionFields.strike.toFixed(2)}
)}
- {(order as Record).expiry && (
+ {optionFields.expiry && (
- Expiry
- - {formatDate(String((order as Record).expiry))}
+ - {formatDate(optionFields.expiry)}
)}
- {(order as Record).contract_multiplier != null && (
+ {optionFields.contractMultiplier != null && (
- Contract multiplier
- - {String((order as Record).contract_multiplier)}
+ - {String(optionFields.contractMultiplier)}
)}
- {(order as Record).position_intent && (
+ {optionFields.positionIntent && (
- Position intent
- - {String((order as Record).position_intent)}
+ - {optionFields.positionIntent}
)}
diff --git a/web/src/pages/pipeline-run-page.tsx b/web/src/pages/pipeline-run-page.tsx
index fd68771d..ec05c3be 100644
--- a/web/src/pages/pipeline-run-page.tsx
+++ b/web/src/pages/pipeline-run-page.tsx
@@ -41,6 +41,10 @@ const legacyRiskRoleMap: Partial> = {
neutral_risk: 'neutral_analyst',
};
+function isRecord(value: unknown): value is Record {
+ return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
function normalizeAgentRole(role: AgentRole): AgentRole {
return legacyRiskRoleMap[role] ?? role;
}
@@ -209,6 +213,8 @@ export function PipelineRunPage() {
() => computePhases(decisions, run?.status === 'completed', Boolean(run?.signal)),
[decisions, run?.signal, run?.status],
);
+ const phaseTimings = isRecord(run?.phase_timings) ? run.phase_timings : null;
+ const configSnapshot = run?.config_snapshot;
if (runLoading) {
return (
@@ -311,33 +317,31 @@ export function PipelineRunPage() {
Phase Timings
- {Object.entries(run.phase_timings as Record).map(
- ([phase, duration]) => (
- -
- {phase}
- {String(duration)}
-
- ),
- )}
+ {Object.entries(phaseTimings).map(([phase, duration]) => (
+ -
+ {phase}
+ {String(duration)}
+
+ ))}
)}
- {run.config_snapshot && (
+ {configSnapshot != null && (
Config Snapshot
- {JSON.stringify(run.config_snapshot, null, 2)}
+ {JSON.stringify(configSnapshot, null, 2)}
)}
diff --git a/web/src/pages/realtime-page.tsx b/web/src/pages/realtime-page.tsx
index 31c1592b..1659e140 100644
--- a/web/src/pages/realtime-page.tsx
+++ b/web/src/pages/realtime-page.tsx
@@ -2,7 +2,7 @@ import { useQuery, useQueryClient } from '@tanstack/react-query';
import {
Activity,
AlertCircle,
- ArrowDown,
+ ArrowUp,
Brain,
CandlestickChart,
CircleDot,
@@ -139,7 +139,7 @@ function toFeedItem(message: WebSocketMessage): FeedItem {
function sortEvents(events: FeedItem[]) {
return [...events].sort(
- (a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime(),
+ (a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime(),
);
}
@@ -707,7 +707,7 @@ export function RealtimePage() {
return;
}
- feedRef.current.scrollTop = feedRef.current.scrollHeight;
+ feedRef.current.scrollTop = 0;
}, [autoScroll, events]);
function handleFeedScroll() {
@@ -716,14 +716,14 @@ export function RealtimePage() {
return;
}
- const nearBottom = element.scrollHeight - element.scrollTop - element.clientHeight < 24;
- setAutoScroll(nearBottom);
+ const nearTop = element.scrollTop < 24;
+ setAutoScroll(nearTop);
}
function resumeScroll() {
setAutoScroll(true);
if (feedRef.current) {
- feedRef.current.scrollTop = feedRef.current.scrollHeight;
+ feedRef.current.scrollTop = 0;
}
}
@@ -888,7 +888,7 @@ export function RealtimePage() {
onClick={resumeScroll}
data-testid="realtime-resume-scroll"
>
-
+
Resume live scroll
) : null}
@@ -898,9 +898,9 @@ export function RealtimePage() {
/>
-
+ {/* Feed panel — second on mobile, first (left) on xl */}
+
-
Event feed
@@ -1002,7 +1002,8 @@ export function RealtimePage() {
-
+ {/* Viewer/chat panel — first on mobile, second (right) on xl */}
+
{selectedEvent ? (
{
expect(screen.getByTestId('risk-page')).toBeInTheDocument()
expect(await screen.findByText('Open')).toBeInTheDocument()
expect(screen.getByText('Inactive')).toBeInTheDocument()
- expect(screen.getByTestId('kill-switch-toggle')).toHaveTextContent('Activate')
+ expect(screen.getByTestId('kill-switch-toggle')).toHaveTextContent('Stop All')
expect(await screen.findByTestId('audit-log-table')).toBeInTheDocument()
expect(screen.getByText('kill_switch_toggled')).toBeInTheDocument()
expect(screen.getByText('risk')).toBeInTheDocument()
@@ -124,7 +124,7 @@ describe('RiskPage', () => {
expect(await screen.findByText('Active')).toBeInTheDocument()
expect(screen.getByText('Emergency halt')).toBeInTheDocument()
- expect(screen.getByTestId('kill-switch-toggle')).toHaveTextContent('Deactivate')
+ expect(screen.getByTestId('kill-switch-toggle')).toHaveTextContent('Resume All')
})
it('loads more audit entries when requested', async () => {
diff --git a/web/src/pages/risk-page.tsx b/web/src/pages/risk-page.tsx
index 451a3b36..2699835f 100644
--- a/web/src/pages/risk-page.tsx
+++ b/web/src/pages/risk-page.tsx
@@ -1,4 +1,5 @@
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
+import { Power } from 'lucide-react'
import { useState } from 'react'
import { PageHeader } from '@/components/layout/page-header'
@@ -202,7 +203,7 @@ export function RiskPage() {
{showReasonInput && !killSwitch.active ? (
-
+
) : null}
diff --git a/web/src/pages/stock-detail-page.tsx b/web/src/pages/stock-detail-page.tsx
index 81577042..19b6b59d 100644
--- a/web/src/pages/stock-detail-page.tsx
+++ b/web/src/pages/stock-detail-page.tsx
@@ -8,6 +8,8 @@ import {
FileText,
FlaskConical,
Loader2,
+ MessageSquare,
+ Newspaper,
Play,
Receipt,
Sparkles,
@@ -314,8 +316,58 @@ export function StockDetailPage() {
{/* Two-column layout */}
- {/* Left column: strategies, orders, trades, positions */}
+ {/* Left column: price chart stub, news stub, social stub, strategies, orders, trades, positions */}
+ {/* Price Chart — stub (endpoint not yet available) */}
+
+
+
+
+ Price chart
+
+
+
+
+
+ Price chart data not yet available
+
+
+
+ {/* News — stub (endpoint not yet available) */}
+
+
+
+
+ News
+
+
+
+
+
+ News feed not yet available
+
+
+
+ {/* Social Sentiment — stub (endpoint not yet available) */}
+
+
+
+
+ Social sentiment
+
+
+
+
+
+ Social sentiment not yet available
+
+
{/* Active Strategies */}
diff --git a/web/src/pages/strategies-page.tsx b/web/src/pages/strategies-page.tsx
index fa1c4ba5..092ec346 100644
--- a/web/src/pages/strategies-page.tsx
+++ b/web/src/pages/strategies-page.tsx
@@ -1,5 +1,5 @@
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
-import { Activity, Clock, Pause, Play, Plus, Search } from 'lucide-react'
+import { Activity, Clock, Pause, Play, Plus } from 'lucide-react'
import { useState } from 'react'
import { Link } from 'react-router-dom'
@@ -8,16 +8,10 @@ import { CreateStrategyDialog } from '@/components/strategies/create-strategy-di
import { Badge } from '@/components/ui/badge'
import { Button } from '@/components/ui/button'
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
-import { Input } from '@/components/ui/input'
import { apiClient } from '@/lib/api/client'
-import type { MarketType, Strategy, StrategyCreateRequest, StrategyStatus } from '@/lib/api/types'
+import type { Strategy, StrategyCreateRequest, StrategyStatus } from '@/lib/api/types'
import { describeCron } from '@/lib/cron-describe'
-const MARKET_TYPE_OPTIONS: MarketType[] = ['stock', 'crypto', 'polymarket']
-const STATUS_OPTIONS: StrategyStatus[] = ['active', 'paused', 'inactive']
-const denseSelectClassName =
- 'flex h-9 w-full rounded-md border border-input bg-card px-3 py-1 text-sm text-foreground transition-colors focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring'
-
function MarketTypeBadge({ type }: { type: Strategy['market_type'] }) {
const variants: Record = {
stock: 'default',
@@ -59,44 +53,11 @@ export function StrategiesPage() {
const [createOpen, setCreateOpen] = useState(false)
const queryClient = useQueryClient()
- // Filter state (draft -> applied on button click)
- const [draftTicker, setDraftTicker] = useState('')
- const [draftMarketType, setDraftMarketType] = useState('')
- const [draftStatus, setDraftStatus] = useState('')
- const [draftIsPaper, setDraftIsPaper] = useState<'' | 'true' | 'false'>('')
-
- const [ticker, setTicker] = useState('')
- const [marketType, setMarketType] = useState('')
- const [status, setStatus] = useState('')
- const [isPaper, setIsPaper] = useState<'' | 'true' | 'false'>('')
-
- function applyFilters() {
- setTicker(draftTicker.trim())
- setMarketType(draftMarketType)
- setStatus(draftStatus)
- setIsPaper(draftIsPaper)
- }
-
- function clearFilters() {
- setDraftTicker('')
- setDraftMarketType('')
- setDraftStatus('')
- setDraftIsPaper('')
- setTicker('')
- setMarketType('')
- setStatus('')
- setIsPaper('')
- }
-
const { data, isLoading, isError } = useQuery({
- queryKey: ['strategies', ticker, marketType, status, isPaper],
+ queryKey: ['strategies'],
queryFn: () =>
apiClient.listStrategies({
limit: 100,
- ticker: ticker || undefined,
- market_type: marketType || undefined,
- status: status || undefined,
- is_paper: isPaper === 'true' ? true : isPaper === 'false' ? false : undefined,
}),
refetchInterval: 30_000,
})
diff --git a/web/src/pages/universe-page.tsx b/web/src/pages/universe-page.tsx
index 90cebdae..9877fb72 100644
--- a/web/src/pages/universe-page.tsx
+++ b/web/src/pages/universe-page.tsx
@@ -276,7 +276,7 @@ export function UniversePage() {
)}
{!scanMutation.data && watchlist.length > 0 && (
-
+
)}
{!scanMutation.data &&
|