@tradejs/app 2.0.19 → 2.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/app",
-  "version": "2.0.19",
+  "version": "2.0.20",
   "description": "Installable Next.js UI for the TradeJS TypeScript framework: dashboards, backtests, charts, and runtime data.",
   "keywords": [
     "tradejs",
@@ -51,13 +51,13 @@
     "@emotion/react": "^11.14.0",
     "@langchain/core": "^1.2.3",
     "@langchain/openai": "^1.5.5",
-    "@tradejs/connectors": "^2.0.19",
-    "@tradejs/core": "^2.0.19",
-    "@tradejs/indicators": "^2.0.19",
-    "@tradejs/infra": "^2.0.19",
-    "@tradejs/node": "^2.0.19",
-    "@tradejs/strategies": "^2.0.19",
-    "@tradejs/types": "^2.0.19",
+    "@tradejs/connectors": "^2.0.20",
+    "@tradejs/core": "^2.0.20",
+    "@tradejs/indicators": "^2.0.20",
+    "@tradejs/infra": "^2.0.20",
+    "@tradejs/node": "^2.0.20",
+    "@tradejs/strategies": "^2.0.20",
+    "@tradejs/types": "^2.0.20",
     "@types/bcryptjs": "2.4.6",
     "@types/lodash": "4.17.24",
     "@types/node": "24.13.3",

package/src/app/api/signal/[symbol]/[signalId]/route.ts

@@ -30,8 +30,9 @@ export const GET = async (
       );
     }
 
-    const signal: Signal = await getData(
+    const signal: Signal | null = await getData(
       redisKeys.storeSignal(symbol, signalId),
+      null,
     );
 
     return NextResponse.json({ signal });

package/src/app/components/Strategies/RuntimeStrategyCard.tsx

@@ -1405,9 +1405,7 @@ export const RuntimeStrategyCard = ({
       <RuntimeStrategyChart
         orderLog={strategy.orderLog}
         stat={strategy.stat}
-        aiGateObservedFrom={strategy.aiGateObservedFrom}
-        aiGateChanges={strategy.aiGateChanges}
-        maxLossValueTimeline={strategy.maxLossValueTimeline}
+        evidenceTimeline={strategy.evidenceTimeline}
         startTimestamp={startTimestamp}
         endTimestamp={endTimestamp}
       />

package/src/app/components/Strategies/RuntimeStrategyChart.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { useMemo } from 'react';
+import { useMemo, useState } from 'react';
 import { Box, Flex, Text } from '@chakra-ui/react';
 import { Chart, useChart } from '@chakra-ui/charts';
 import {
@@ -13,20 +13,24 @@ import {
   YAxis,
 } from 'recharts';
 import { getFormatted } from '@tradejs/core/backtest';
-import type { SimpleOrderLogData, TestStat } from '@tradejs/types';
 import type {
-  RuntimeStrategyAiGateChange,
-  RuntimeStrategyMaxLossValueTimeline,
-} from '#app/lib/runtimeStrategies';
+  SimpleOrderLogData,
+  StrategyEvidenceMarkerType,
+  StrategyEvidenceTimeline,
+  TestStat,
+} from '@tradejs/types';
 import { formatTimeSeriesTooltipTimestamp } from '#app/lib/timeSeriesChart';
 import { TimeSeriesXAxis } from '#shared/Charts/TimeSeriesXAxis';
+import {
+  filterStrategyEvidenceMarkers,
+  STRATEGY_EVIDENCE_MARKER_PRESENTATION,
+  StrategyEvidencePopover,
+} from './StrategyEvidencePopover';
 
 interface RuntimeStrategyChartProps {
   orderLog: SimpleOrderLogData;
   stat: TestStat;
-  aiGateObservedFrom: number | null;
-  aiGateChanges: RuntimeStrategyAiGateChange[];
-  maxLossValueTimeline: RuntimeStrategyMaxLossValueTimeline;
+  evidenceTimeline: StrategyEvidenceTimeline;
   startTimestamp: number;
   endTimestamp: number;
   height?: string | number;
@@ -35,13 +39,13 @@ interface RuntimeStrategyChartProps {
 export const RuntimeStrategyChart = ({
   orderLog,
   stat,
-  aiGateObservedFrom,
-  aiGateChanges,
-  maxLossValueTimeline,
+  evidenceTimeline,
   startTimestamp,
   endTimestamp,
   height = '350px',
 }: RuntimeStrategyChartProps) => {
+  const [showParity, setShowParity] = useState(true);
+  const [showRecommendations, setShowRecommendations] = useState(true);
   const chartData = useMemo(
     () => ({
       data: orderLog.map(([timestamp, amount]) => ({
@@ -61,193 +65,120 @@ export const RuntimeStrategyChart = ({
   const chart = useChart(chartData as any);
   const { formatted: maxAmount } = getFormatted(stat, 'maxAmount');
   const { formatted: minAmount } = getFormatted(stat, 'minAmount');
-  const gateChangeColor = chart.color('purple.400');
-  const maxLossValueChangeColor = chart.color('orange.400');
-
-  if (!orderLog.length) {
-    return (
-      <Box
-        w="100%"
-        minW="600px"
-        h={height}
-        display="flex"
-        alignItems="center"
-        justifyContent="center"
-      >
-        <Text color="gray.500">No runtime trades for the selected window.</Text>
-      </Box>
-    );
-  }
+  const visibleEvidenceMarkers = filterStrategyEvidenceMarkers({
+    markers:
+      evidenceTimeline.status === 'verified' ? evidenceTimeline.markers : [],
+    showParity,
+    showRecommendations,
+  });
+  const markerColor = (type: StrategyEvidenceMarkerType) =>
+    chart.color(STRATEGY_EVIDENCE_MARKER_PRESENTATION[type].color);
+  const markerDash = (type: StrategyEvidenceMarkerType) => {
+    if (type === 'L') return '7 4';
+    if (type === 'P' || type === 'R') return '2 5';
+    return '3 5';
+  };
 
   return (
     <Box w="100%" minW="600px" h={height} display="flex" flexDirection="column">
-      {aiGateObservedFrom != null ? (
-        <Flex
-          minH="24px"
-          px={2}
-          gap={4}
-          alignItems="center"
-          overflowX="auto"
-          flexShrink={0}
-          whiteSpace="nowrap"
-        >
-          <Text
-            flexShrink={0}
-            fontSize="xs"
-            color="gray.500"
-            title="AI-gate changes before this first runtime observation are unavailable"
-          >
-            AI-gate history from{' '}
-            {formatTimeSeriesTooltipTimestamp(aiGateObservedFrom)}
-          </Text>
-          {aiGateChanges.map((change, index) => (
-            <Text
-              key={`${change.timestamp}:${change.fingerprint}:legend`}
-              flexShrink={0}
-              fontSize="xs"
-              color="gray.400"
-              title={`${change.previousFingerprint} → ${change.fingerprint}`}
-            >
-              <Text as="span" color={gateChangeColor} fontWeight="semibold">
-                G{index + 1}
-              </Text>{' '}
-              {formatTimeSeriesTooltipTimestamp(change.timestamp)} ·{' '}
-              {change.fingerprint.slice(0, 7)}
-            </Text>
-          ))}
-          {maxLossValueTimeline.observedFrom != null &&
-          maxLossValueTimeline.initialValue != null ? (
-            <Text
-              flexShrink={0}
-              fontSize="xs"
-              color="gray.500"
-              title="MAX_LOSS_VALUE changes before this first runtime observation are unavailable"
-            >
-              MAX_LOSS_VALUE history from{' '}
-              {formatTimeSeriesTooltipTimestamp(
-                maxLossValueTimeline.observedFrom,
-              )}{' '}
-              · initial {maxLossValueTimeline.initialValue}$
-            </Text>
-          ) : null}
-          {maxLossValueTimeline.changes.map((change, index) => (
-            <Text
-              key={`${change.timestamp}:${change.value}:max-loss-legend`}
-              flexShrink={0}
-              fontSize="xs"
-              color="gray.400"
-            >
-              <Text
-                as="span"
-                color={maxLossValueChangeColor}
-                fontWeight="semibold"
-              >
-                L{index + 1}
-              </Text>{' '}
-              {formatTimeSeriesTooltipTimestamp(change.timestamp)} ·{' '}
-              {change.previousValue}$ → {change.value}$
-            </Text>
-          ))}
-        </Flex>
-      ) : null}
+      <Flex minH="32px" px={2} justify="flex-end" align="center" flexShrink={0}>
+        <StrategyEvidencePopover
+          timeline={evidenceTimeline}
+          showParity={showParity}
+          showRecommendations={showRecommendations}
+          onShowParityChange={setShowParity}
+          onShowRecommendationsChange={setShowRecommendations}
+        />
+      </Flex>
       <Box flex="1" minH={0} pr={2}>
-        <ResponsiveContainer width="100%" height="100%">
-          <Chart.Root maxH="md" chart={chart}>
-            <LineChart data={chart.data}>
-              <CartesianGrid stroke={chart.color('border')} vertical={false} />
-              <ReferenceLine
-                stroke={chart.color('gray.600')}
-                strokeDasharray="5 5"
-                y={stat.maxAmount}
-                label={{
-                  value: `Max: ${maxAmount}`,
-                  offset: 10,
-                  fill: chart.color('gray.600'),
-                  position: 'top',
-                }}
-              />
-              <ReferenceLine
-                stroke={chart.color('gray.600')}
-                strokeDasharray="8 8"
-                y={100}
-              />
-              <ReferenceLine
-                stroke={chart.color('gray.600')}
-                strokeDasharray="5 5"
-                y={stat.minAmount}
-                label={{
-                  value: `Min: ${minAmount}`,
-                  offset: 10,
-                  fill: chart.color('gray.600'),
-                  position: 'bottom',
-                }}
-              />
-              {aiGateChanges.map((change, index) => (
+        {orderLog.length ? (
+          <ResponsiveContainer width="100%" height="100%">
+            <Chart.Root maxH="md" chart={chart}>
+              <LineChart data={chart.data}>
+                <CartesianGrid
+                  stroke={chart.color('border')}
+                  vertical={false}
+                />
                 <ReferenceLine
-                  key={`${change.timestamp}:${change.fingerprint}`}
-                  x={change.timestamp}
-                  stroke={gateChangeColor}
-                  strokeDasharray="3 5"
-                  strokeWidth={1.5}
+                  stroke={chart.color('gray.600')}
+                  strokeDasharray="5 5"
+                  y={stat.maxAmount}
                   label={{
-                    value: `G${index + 1}`,
-                    fill: gateChangeColor,
-                    fontSize: 10,
-                    fontWeight: 600,
-                    offset: 6,
-                    position:
-                      index % 2 === 0 ? 'insideTopRight' : 'insideTopLeft',
+                    value: `Max: ${maxAmount}`,
+                    offset: 10,
+                    fill: chart.color('gray.600'),
+                    position: 'top',
                   }}
                 />
-              ))}
-              {maxLossValueTimeline.changes.map((change, index) => (
                 <ReferenceLine
-                  key={`${change.timestamp}:${change.value}:max-loss`}
-                  x={change.timestamp}
-                  stroke={maxLossValueChangeColor}
-                  strokeDasharray="7 4"
-                  strokeWidth={1.5}
+                  stroke={chart.color('gray.600')}
+                  strokeDasharray="8 8"
+                  y={100}
+                />
+                <ReferenceLine
+                  stroke={chart.color('gray.600')}
+                  strokeDasharray="5 5"
+                  y={stat.minAmount}
                   label={{
-                    value: `L${index + 1}`,
-                    fill: maxLossValueChangeColor,
-                    fontSize: 10,
-                    fontWeight: 600,
-                    offset: 6,
-                    position:
-                      index % 2 === 0
-                        ? 'insideBottomRight'
-                        : 'insideBottomLeft',
+                    value: `Min: ${minAmount}`,
+                    offset: 10,
+                    fill: chart.color('gray.600'),
+                    position: 'bottom',
                   }}
                 />
-              ))}
-              <TimeSeriesXAxis
-                startTimestamp={startTimestamp}
-                endTimestamp={endTimestamp}
-              />
-              <YAxis tickCount={10} domain={[stat.minAmount - 10, 'auto']} />
-              <Tooltip
-                animationDuration={100}
-                cursor={false}
-                content={
-                  <Chart.Tooltip
-                    labelFormatter={formatTimeSeriesTooltipTimestamp}
+                {visibleEvidenceMarkers.map((marker, index) => (
+                  <ReferenceLine
+                    key={marker.id}
+                    x={marker.timestamp}
+                    stroke={markerColor(marker.type)}
+                    strokeDasharray={markerDash(marker.type)}
+                    strokeWidth={1.5}
+                    label={{
+                      value: marker.type,
+                      fill: markerColor(marker.type),
+                      fontSize: 10,
+                      fontWeight: 600,
+                      offset: 6,
+                      position:
+                        index % 2 === 0 ? 'insideTopRight' : 'insideTopLeft',
+                    }}
                   />
-                }
-              />
-              {chart.series.map((item) => (
-                <Line
-                  key={item.name as string}
-                  isAnimationActive={false}
-                  dataKey={chart.key(item.name) as string}
-                  stroke={chart.color(item.color)}
-                  strokeWidth={2}
-                  dot={false}
-                  activeDot={{ r: 5, strokeWidth: 2 }}
+                ))}
+                <TimeSeriesXAxis
+                  startTimestamp={startTimestamp}
+                  endTimestamp={endTimestamp}
                 />
-              ))}
-            </LineChart>
-          </Chart.Root>
-        </ResponsiveContainer>
+                <YAxis tickCount={10} domain={[stat.minAmount - 10, 'auto']} />
+                <Tooltip
+                  animationDuration={100}
+                  cursor={false}
+                  content={
+                    <Chart.Tooltip
+                      labelFormatter={formatTimeSeriesTooltipTimestamp}
+                    />
+                  }
+                />
+                {chart.series.map((item) => (
+                  <Line
+                    key={item.name as string}
+                    isAnimationActive={false}
+                    dataKey={chart.key(item.name) as string}
+                    stroke={chart.color(item.color)}
+                    strokeWidth={2}
+                    dot={false}
+                    activeDot={{ r: 5, strokeWidth: 2 }}
+                  />
+                ))}
+              </LineChart>
+            </Chart.Root>
+          </ResponsiveContainer>
+        ) : (
+          <Flex h="100%" align="center" justify="center">
+            <Text color="gray.500">
+              No runtime trades for the selected window.
+            </Text>
+          </Flex>
+        )}
       </Box>
     </Box>
   );

package/src/app/components/Strategies/StrategyEvidencePopover.tsx

@@ -0,0 +1,259 @@
+'use client';
+
+import {
+  Badge,
+  Box,
+  Button,
+  Checkbox,
+  Flex,
+  Popover,
+  Portal,
+  Text,
+} from '@chakra-ui/react';
+import type {
+  StrategyEvidenceMarker,
+  StrategyEvidenceMarkerType,
+  StrategyEvidenceTimeline,
+} from '@tradejs/types';
+import { formatTimeSeriesTooltipTimestamp } from '#app/lib/timeSeriesChart';
+
+export const STRATEGY_EVIDENCE_MARKER_PRESENTATION: Record<
+  StrategyEvidenceMarkerType,
+  { name: string; color: string; optional: boolean }
+> = {
+  G: { name: 'Composition / gate', color: 'purple.400', optional: false },
+  L: { name: 'MAX_LOSS_VALUE', color: 'orange.400', optional: false },
+  E: { name: 'Evidence boundary', color: 'teal.400', optional: false },
+  D: { name: 'Deployment', color: 'blue.400', optional: false },
+  P: { name: 'Runtime parity', color: 'cyan.400', optional: true },
+  R: { name: 'Recommendation', color: 'pink.400', optional: true },
+};
+
+const MARKER_TYPES = Object.keys(
+  STRATEGY_EVIDENCE_MARKER_PRESENTATION,
+) as StrategyEvidenceMarkerType[];
+
+export const filterStrategyEvidenceMarkers = ({
+  markers,
+  showParity,
+  showRecommendations,
+}: {
+  markers: StrategyEvidenceMarker[];
+  showParity: boolean;
+  showRecommendations: boolean;
+}) =>
+  markers.filter(
+    (marker) =>
+      (marker.type !== 'P' || showParity) &&
+      (marker.type !== 'R' || showRecommendations),
+  );
+
+const statusColor = (status: StrategyEvidenceTimeline['status']) => {
+  if (status === 'verified') return 'teal';
+  if (status === 'invalid') return 'red';
+  return 'orange';
+};
+
+const uniqueProvenance = (markers: StrategyEvidenceMarker[]) => {
+  const seen = new Set<string>();
+  return markers.filter((marker) => {
+    const key = `${marker.artifactId}:${marker.artifactSha256}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};
+
+const FilterCheckbox = ({
+  checked,
+  label,
+  onChange,
+}: {
+  checked: boolean;
+  label: string;
+  onChange: (checked: boolean) => void;
+}) => (
+  <Checkbox.Root
+    size="sm"
+    checked={checked}
+    onCheckedChange={({ checked: nextChecked }) =>
+      onChange(nextChecked === true)
+    }
+  >
+    <Checkbox.HiddenInput />
+    <Checkbox.Control>
+      <Checkbox.Indicator />
+    </Checkbox.Control>
+    <Checkbox.Label>{label}</Checkbox.Label>
+  </Checkbox.Root>
+);
+
+export const StrategyEvidencePopover = ({
+  timeline,
+  showParity,
+  showRecommendations,
+  onShowParityChange,
+  onShowRecommendationsChange,
+}: {
+  timeline: StrategyEvidenceTimeline;
+  showParity: boolean;
+  showRecommendations: boolean;
+  onShowParityChange: (checked: boolean) => void;
+  onShowRecommendationsChange: (checked: boolean) => void;
+}) => {
+  const provenance =
+    timeline.status === 'verified' ? uniqueProvenance(timeline.markers) : [];
+
+  return (
+    <Popover.Root positioning={{ placement: 'bottom-end' }} lazyMount>
+      <Popover.Trigger asChild>
+        <Button
+          size="xs"
+          variant="outline"
+          aria-label={`Evidence: ${timeline.status}`}
+        >
+          Evidence
+          <Badge size="xs" colorPalette={statusColor(timeline.status)}>
+            {timeline.status === 'verified'
+              ? `${timeline.markers.length}`
+              : timeline.status}
+          </Badge>
+        </Button>
+      </Popover.Trigger>
+      <Portal>
+        <Popover.Positioner>
+          <Popover.Content width="min(430px, calc(100vw - 24px))">
+            <Popover.Arrow />
+            <Popover.Body>
+              <Flex direction="column" gap={3}>
+                <Box>
+                  <Text fontWeight="semibold">Immutable evidence</Text>
+                  <Text fontSize="xs" color="gray.500">
+                    {timeline.status === 'verified'
+                      ? timeline.observedFrom == null
+                        ? 'Verified artifact; no observation boundary supplied.'
+                        : `Verified from ${formatTimeSeriesTooltipTimestamp(
+                            timeline.observedFrom,
+                          )}.`
+                      : timeline.status === 'invalid'
+                        ? 'Evidence failed checksum, identity, or structure verification. No markers are rendered.'
+                        : 'No checksum-verified evidence artifact is available. No mutable fallback is used.'}
+                  </Text>
+                </Box>
+
+                <Box>
+                  <Text fontSize="xs" fontWeight="semibold" mb={1}>
+                    Legend
+                  </Text>
+                  <Flex wrap="wrap" gapX={3} gapY={1}>
+                    {MARKER_TYPES.map((type) => (
+                      <Flex key={type} align="center" gap={1}>
+                        <Text
+                          color={
+                            STRATEGY_EVIDENCE_MARKER_PRESENTATION[type].color
+                          }
+                          fontWeight="bold"
+                          fontSize="xs"
+                        >
+                          {type}
+                        </Text>
+                        <Text fontSize="xs" color="gray.500">
+                          {STRATEGY_EVIDENCE_MARKER_PRESENTATION[type].name}
+                        </Text>
+                      </Flex>
+                    ))}
+                  </Flex>
+                </Box>
+
+                <Box>
+                  <Text fontSize="xs" fontWeight="semibold" mb={1}>
+                    Optional markers
+                  </Text>
+                  <Flex gap={4}>
+                    <FilterCheckbox
+                      checked={showParity}
+                      label="Parity (P)"
+                      onChange={onShowParityChange}
+                    />
+                    <FilterCheckbox
+                      checked={showRecommendations}
+                      label="Recommendations (R)"
+                      onChange={onShowRecommendationsChange}
+                    />
+                  </Flex>
+                </Box>
+
+                <Box>
+                  <Text fontSize="xs" fontWeight="semibold" mb={1}>
+                    Events and provenance
+                  </Text>
+                  {timeline.status === 'verified' && timeline.markers.length ? (
+                    <Flex
+                      direction="column"
+                      gap={2}
+                      maxH="220px"
+                      overflowY="auto"
+                    >
+                      {timeline.markers.map((marker) => (
+                        <Box key={marker.id}>
+                          <Flex align="baseline" gap={2}>
+                            <Text
+                              color={
+                                STRATEGY_EVIDENCE_MARKER_PRESENTATION[
+                                  marker.type
+                                ].color
+                              }
+                              fontWeight="bold"
+                              fontSize="xs"
+                            >
+                              {marker.type}
+                            </Text>
+                            <Text fontSize="xs" fontWeight="semibold">
+                              {marker.label}
+                            </Text>
+                            <Text fontSize="xs" color="gray.500">
+                              {formatTimeSeriesTooltipTimestamp(
+                                marker.timestamp,
+                              )}
+                            </Text>
+                          </Flex>
+                          <Text fontSize="xs" color="gray.500">
+                            {marker.summary}
+                          </Text>
+                        </Box>
+                      ))}
+                    </Flex>
+                  ) : (
+                    <Text fontSize="xs" color="gray.500">
+                      No verified events in the selected window.
+                    </Text>
+                  )}
+                </Box>
+
+                {provenance.length ? (
+                  <Box>
+                    <Text fontSize="xs" fontWeight="semibold" mb={1}>
+                      Artifact provenance
+                    </Text>
+                    {provenance.map((marker) => (
+                      <Text
+                        key={`${marker.artifactId}:${marker.artifactSha256}`}
+                        fontSize="xs"
+                        color="gray.500"
+                        fontFamily="mono"
+                        title={marker.artifactSha256}
+                      >
+                        {marker.artifactId} ·{' '}
+                        {marker.artifactSha256.slice(0, 12)}
+                      </Text>
+                    ))}
+                  </Box>
+                ) : null}
+              </Flex>
+            </Popover.Body>
+          </Popover.Content>
+        </Popover.Positioner>
+      </Portal>
+    </Popover.Root>
+  );
+};

package/src/app/lib/runtimeDashboard.ts

@@ -1,5 +1,6 @@
 import { getRuntimeStorageDayKeys } from '@tradejs/core/time';
 import { logger } from '@tradejs/infra/logger';
+import { strategyEvidenceFingerprint } from '@tradejs/infra/strategyReleaseEvidence';
 import {
   listTradingAccounts,
   resolveTradingAccount,
@@ -35,13 +36,12 @@ import {
 } from '#app/lib/runtimeStrategies';
 import {
   assignLegacyRuntimeTradeAccountScopes,
-  buildRuntimeStrategyAiGateChanges,
   buildRuntimeStrategyIdentityKey,
-  buildRuntimeStrategyMaxLossValueTimeline,
-  getRuntimeStrategyAiGateObservedFrom,
-  isRuntimeStrategyLineageScope,
-  type RuntimeStrategyLineageScope,
 } from '#app/lib/runtimeStrategyLineage';
+import {
+  loadStrategyEvidenceTimelines,
+  strategyEvidenceTimelineSelectorKey,
+} from '#app/lib/strategyEvidenceTimeline';
 import {
   isRuntimeTradeInConnectorScope,
   syncRuntimeTrades,
@@ -53,7 +53,6 @@ const MIN_HOURS = 6;
 const MAX_HOURS = 24 * 90;
 const BYBIT_MAX_TIME_RANGE_MS = 7 * 24 * 60 * 60 * 1000 - 1_000;
 const EXCHANGE_REQUEST_TIMEOUT_MS = 15_000;
-const RUNTIME_LINEAGE_HISTORY_MS = 30 * 24 * 60 * 60 * 1000;
 
 const coerceHours = (value: string | number | null | undefined) => {
   const parsed = Number(value ?? Number.NaN);
@@ -151,25 +150,6 @@ const loadRuntimeTrades = async (
     .sort((left, right) => left.entryTimestamp - right.entryTimestamp);
 };
 
-const loadRuntimeLineageScopes = async (
-  userName: string,
-  endTime: number,
-): Promise<RuntimeStrategyLineageScope[]> =>
-  (
-    await Promise.all(
-      getRuntimeStorageDayKeys(
-        Math.max(0, endTime - RUNTIME_LINEAGE_HISTORY_MS),
-        endTime,
-      ).map((dayKey) =>
-        getHashJsonValues<RuntimeStrategyLineageScope>(
-          redisKeys.runtimeLineageScopeBucket(userName, dayKey),
-        ),
-      ),
-    )
-  )
-    .flat()
-    .filter(isRuntimeStrategyLineageScope);
-
 const buildExchangeTimeRanges = (startTime: number, endTime: number) => {
   const ranges: Array<{ startTime: number; endTime: number }> = [];
   let cursor = startTime;
@@ -399,7 +379,6 @@ export const loadRuntimeDashboard = async ({
     openPositionsSnapshot,
     runtimeDeployments,
     tradingAccounts,
-    runtimeLineageScopes,
   ] = await Promise.all([
     loadRuntimeStrategyConfigs(userName),
     loadConfiguredStrategyNames(projectRoot),
@@ -420,7 +399,6 @@ export const loadRuntimeDashboard = async ({
     loadOpenPositions(connector, exchangeErrors),
     listRuntimeDeployments(userName),
     listTradingAccounts(userName),
-    loadRuntimeLineageScopes(userName, endTime),
   ]);
   const relevantTrades = selectTradesForWindow(
     runtimeTrades,
@@ -488,9 +466,15 @@ export const loadRuntimeDashboard = async ({
       accountLabel?: string;
       deploymentId?: string;
       policyProfileId?: string;
+      releaseCompositionId?: string;
       enabled?: boolean;
       config?: Record<string, unknown>;
       connected?: boolean;
+      gitSha?: string;
+      configFingerprint?: string;
+      gateFingerprint?: string;
+      contextFingerprint?: string;
+      maxLossValue?: number;
     }
   >();
   const runtimeConfigAccountScopes = new Array<{
@@ -518,9 +502,13 @@ export const loadRuntimeDashboard = async ({
         accountLabel: accountsById.get(deployment.accountId)?.label,
         deploymentId: deployment.id,
         policyProfileId: deploymentStrategy.policyProfileId,
+        releaseCompositionId: deploymentStrategy.releaseCompositionId,
         enabled: deployment.enabled && deploymentStrategy.enabled !== false,
         config: deploymentStrategy.config,
         connected: false,
+        configFingerprint: strategyEvidenceFingerprint(
+          deploymentStrategy.config,
+        ),
       });
     }
   }
@@ -561,6 +549,7 @@ export const loadRuntimeDashboard = async ({
       enabled: isRuntimeStrategyConfigEnabled(runtimeConfig.config),
       config: runtimeConfig.config,
       connected: true,
+      configFingerprint: strategyEvidenceFingerprint(runtimeConfig.config),
     });
   }
   const accountScopedTrades = assignLegacyRuntimeTradeAccountScopes(
@@ -569,6 +558,15 @@ export const loadRuntimeDashboard = async ({
   );
   for (const trade of accountScopedTrades) {
     const key = runtimeIdentityKey(trade);
+    const configuredCompositionId =
+      identityByKey.get(key)?.releaseCompositionId;
+    const observedCompositionId = trade.runtimeLineage?.compositionId;
+    const releaseCompositionId =
+      configuredCompositionId &&
+      observedCompositionId &&
+      configuredCompositionId !== observedCompositionId
+        ? undefined
+        : observedCompositionId ?? configuredCompositionId;
     identityByKey.set(key, {
       ...identityByKey.get(key),
       strategyName: trade.strategy,
@@ -581,9 +579,32 @@ export const loadRuntimeDashboard = async ({
         : undefined,
       deploymentId: trade.deploymentId,
       policyProfileId: trade.policyProfileId,
+      releaseCompositionId,
+      configFingerprint: trade.runtimeLineage?.configFingerprint,
+      gateFingerprint: trade.runtimeLineage?.gateFingerprint,
+      contextFingerprint: trade.runtimeLineage?.contextFingerprint,
+      gitSha: trade.runtimeLineage?.gitSha ?? undefined,
+      maxLossValue: trade.runtimeLineage?.maxLossValue ?? undefined,
     });
   }
 
+  const evidenceTimelines = await loadStrategyEvidenceTimelines({
+    projectRoot,
+    markerDir: process.env.STRATEGY_RELEASE_MARKER_DIR,
+    selectors: [...identityByKey.values()].map((identity) => ({
+      strategy: identity.strategyName,
+      compositionId: identity.releaseCompositionId,
+      configFingerprint: identity.configFingerprint,
+      gateFingerprint: identity.gateFingerprint,
+      contextFingerprint: identity.contextFingerprint,
+      gitSha: identity.gitSha,
+      maxLossValue: identity.maxLossValue,
+      requireCompleteLineage: true,
+    })),
+    startTime,
+    endTime,
+  });
+
   const strategies = await Promise.all(
     [...identityByKey.entries()].map(async ([runtimeKey, identity]) => {
       const { strategyName } = identity;
@@ -603,13 +624,6 @@ export const loadRuntimeDashboard = async ({
         startTime,
         endTime,
       });
-      const maxLossValueTimeline = buildRuntimeStrategyMaxLossValueTimeline({
-        scopes: runtimeLineageScopes,
-        strategyName,
-        configId: identity.configId,
-        startTime,
-        endTime,
-      });
       const effectiveStrategyConfig = identity.config ?? null;
 
       return {
@@ -633,20 +647,22 @@ export const loadRuntimeDashboard = async ({
         stat: analytics.stat,
         summary: analytics.summary,
         orderLog: analytics.orderLog,
-        aiGateObservedFrom: getRuntimeStrategyAiGateObservedFrom({
-          scopes: runtimeLineageScopes,
-          strategyName,
-          configId: identity.configId,
-          endTime,
-        }),
-        aiGateChanges: buildRuntimeStrategyAiGateChanges({
-          scopes: runtimeLineageScopes,
-          strategyName,
-          configId: identity.configId,
-          startTime,
-          endTime,
-        }),
-        maxLossValueTimeline,
+        evidenceTimeline: evidenceTimelines.get(
+          strategyEvidenceTimelineSelectorKey({
+            strategy: strategyName,
+            compositionId: identity.releaseCompositionId,
+            configFingerprint: identity.configFingerprint,
+            gateFingerprint: identity.gateFingerprint,
+            contextFingerprint: identity.contextFingerprint,
+            gitSha: identity.gitSha,
+            maxLossValue: identity.maxLossValue,
+            requireCompleteLineage: true,
+          }),
+        ) ?? {
+          status: 'missing',
+          observedFrom: null,
+          markers: [],
+        },
         recentTrades: strategyTrades
           .slice(0, 8)
           .map((trade) => toRuntimeTradeView(trade, endTime)),

package/src/app/lib/runtimeStrategies.ts

@@ -10,14 +10,11 @@ import type {
   RuntimeTradeRecord,
   SimpleOrderLogData,
   StrategyConfig,
+  StrategyEvidenceTimeline,
   TestStat,
   MarketUniverse,
   Interval,
 } from '@tradejs/types';
-import type {
-  RuntimeStrategyAiGateChange,
-  RuntimeStrategyMaxLossValueTimeline,
-} from './runtimeStrategyLineage';
 import {
   takeExactClosedPnlMatch,
   type ClosedPnlRecordWithOrderLinkId,
@@ -106,9 +103,7 @@ export interface RuntimeStrategyView {
   stat: TestStat;
   summary: RuntimeStrategyTradeSummary;
   orderLog: SimpleOrderLogData;
-  aiGateObservedFrom: number | null;
-  aiGateChanges: RuntimeStrategyAiGateChange[];
-  maxLossValueTimeline: RuntimeStrategyMaxLossValueTimeline;
+  evidenceTimeline: StrategyEvidenceTimeline;
   recentTrades: RuntimeStrategyTradeView[];
   orders: RuntimeStrategyTradeView[];
 }

package/src/app/lib/strategyEvidenceTimeline.ts

@@ -0,0 +1,298 @@
+import type { Dirent } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {
+  canonicalStrategyEvidenceJson,
+  safeStrategyEvidenceSegment,
+  verifyStrategyEvidenceMarkerEnvelope,
+} from '@tradejs/infra/strategyReleaseEvidence';
+import {
+  type StrategyEvidenceMarker,
+  type StrategyEvidenceMarkerEnvelope,
+  type StrategyEvidenceTimeline,
+  type StrategyEvidenceTimelineSelector,
+} from '@tradejs/types';
+
+const DEFAULT_MARKER_DIRECTORY = 'data/strategy-release/markers';
+type JsonRecord = Record<string, unknown>;
+
+const asRecord = (value: unknown): JsonRecord | null =>
+  value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as JsonRecord)
+    : null;
+
+const isNonEmptyString = (value: unknown): value is string =>
+  typeof value === 'string' && value.trim().length > 0;
+
+export { canonicalStrategyEvidenceJson, verifyStrategyEvidenceMarkerEnvelope };
+
+export const strategyEvidenceTimelineSelectorKey = (
+  selector: StrategyEvidenceTimelineSelector,
+) =>
+  [
+    selector.strategy,
+    selector.compositionId ?? '',
+    selector.gitSha ?? '',
+    selector.gateFingerprint ?? '',
+    selector.configFingerprint ?? '',
+    selector.contextFingerprint ?? '',
+    selector.requireCompleteLineage ? 'exact' : 'partial',
+  ].join(':');
+
+const discoverJsonFiles = async (rootDir: string): Promise<string[]> => {
+  const files: string[] = [];
+
+  const visit = async (directory: string, depth: number): Promise<void> => {
+    if (depth > 12) return;
+
+    let entries: Dirent[];
+    try {
+      entries = await fs.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return;
+      throw error;
+    }
+
+    await Promise.all(
+      entries.map(async (entry) => {
+        if (entry.name.startsWith('.') || entry.name.includes('.tmp-')) return;
+        const entryPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+          await visit(entryPath, depth + 1);
+        } else if (entry.isFile() && entry.name.endsWith('.json')) {
+          files.push(entryPath);
+        }
+      }),
+    );
+  };
+
+  await visit(rootDir, 0);
+  return files.sort();
+};
+
+const inferMatchingStrategies = ({
+  filePath,
+  rootDir,
+  parsed,
+  strategies,
+}: {
+  filePath: string;
+  rootDir: string;
+  parsed: unknown;
+  strategies: string[];
+}) => {
+  const payload = asRecord(asRecord(parsed)?.payload);
+  const declaredStrategy = isNonEmptyString(payload?.strategy)
+    ? payload.strategy
+    : null;
+  const directoryStrategy = path.relative(rootDir, filePath).split(path.sep)[0];
+  return strategies.filter(
+    (strategy) =>
+      strategy === declaredStrategy ||
+      directoryStrategy === safeStrategyEvidenceSegment(strategy),
+  );
+};
+
+const missingTimeline = (): StrategyEvidenceTimeline => ({
+  status: 'missing',
+  observedFrom: null,
+  markers: [],
+});
+
+const invalidTimeline = (): StrategyEvidenceTimeline => ({
+  status: 'invalid',
+  observedFrom: null,
+  markers: [],
+});
+
+export const loadStrategyEvidenceTimelines = async ({
+  projectRoot,
+  markerDir,
+  selectors: requestedSelectors,
+  startTime,
+  endTime,
+}: {
+  projectRoot: string;
+  markerDir?: string | null;
+  selectors: Iterable<StrategyEvidenceTimelineSelector>;
+  startTime: number;
+  endTime: number;
+}): Promise<Map<string, StrategyEvidenceTimeline>> => {
+  const selectors = [...requestedSelectors]
+    .filter((selector) => selector.strategy.trim().length > 0)
+    .sort((left, right) =>
+      strategyEvidenceTimelineSelectorKey(left).localeCompare(
+        strategyEvidenceTimelineSelectorKey(right),
+      ),
+    );
+  const strategies = [...new Set(selectors.map(({ strategy }) => strategy))];
+  const timelines = new Map(
+    selectors.map((selector) => [
+      strategyEvidenceTimelineSelectorKey(selector),
+      missingTimeline(),
+    ]),
+  );
+  if (!selectors.length) return timelines;
+
+  const configuredDir = markerDir?.trim() || DEFAULT_MARKER_DIRECTORY;
+  const rootDir = path.isAbsolute(configuredDir)
+    ? configuredDir
+    : path.resolve(projectRoot, configuredDir);
+  let files: string[];
+  try {
+    files = await discoverJsonFiles(rootDir);
+  } catch {
+    for (const selector of selectors) {
+      timelines.set(
+        strategyEvidenceTimelineSelectorKey(selector),
+        invalidTimeline(),
+      );
+    }
+    return timelines;
+  }
+
+  const envelopesByStrategy = new Map<
+    string,
+    StrategyEvidenceMarkerEnvelope[]
+  >();
+  const invalidStrategies = new Set<string>();
+
+  for (const filePath of files) {
+    let parsed: unknown = null;
+    try {
+      parsed = JSON.parse(await fs.readFile(filePath, 'utf8')) as unknown;
+    } catch {
+      for (const strategy of inferMatchingStrategies({
+        filePath,
+        rootDir,
+        parsed,
+        strategies,
+      })) {
+        invalidStrategies.add(strategy);
+      }
+      continue;
+    }
+
+    const matchingStrategies = inferMatchingStrategies({
+      filePath,
+      rootDir,
+      parsed,
+      strategies,
+    });
+    if (!matchingStrategies.length) continue;
+
+    try {
+      const envelope = verifyStrategyEvidenceMarkerEnvelope(parsed);
+      for (const strategy of matchingStrategies) {
+        if (strategy !== envelope.payload.strategy) {
+          invalidStrategies.add(strategy);
+        }
+      }
+      if (!strategies.includes(envelope.payload.strategy)) {
+        continue;
+      }
+      const envelopes =
+        envelopesByStrategy.get(envelope.payload.strategy) ?? [];
+      envelopes.push(envelope);
+      envelopesByStrategy.set(envelope.payload.strategy, envelopes);
+    } catch {
+      for (const strategy of matchingStrategies) {
+        invalidStrategies.add(strategy);
+      }
+    }
+  }
+
+  for (const selector of selectors) {
+    const strategy = selector.strategy;
+    const selectorKey = strategyEvidenceTimelineSelectorKey(selector);
+    if (invalidStrategies.has(strategy)) {
+      timelines.set(selectorKey, invalidTimeline());
+      continue;
+    }
+
+    const envelopes = envelopesByStrategy.get(strategy) ?? [];
+    if (!envelopes.length) continue;
+    const hasCompleteSelector =
+      Boolean(selector.compositionId) &&
+      Boolean(selector.gitSha) &&
+      Boolean(selector.gateFingerprint) &&
+      Boolean(selector.configFingerprint) &&
+      Boolean(selector.contextFingerprint);
+    if (selector.requireCompleteLineage && !hasCompleteSelector) continue;
+
+    const markersById = new Map<string, StrategyEvidenceMarker>();
+    let hasConflict = false;
+    for (const envelope of envelopes) {
+      for (const marker of envelope.payload.markers) {
+        const existing = markersById.get(marker.id);
+        if (
+          existing &&
+          canonicalStrategyEvidenceJson(existing) !==
+            canonicalStrategyEvidenceJson(marker)
+        ) {
+          hasConflict = true;
+          break;
+        }
+        markersById.set(marker.id, marker);
+      }
+      if (hasConflict) break;
+    }
+
+    if (hasConflict) {
+      timelines.set(selectorKey, invalidTimeline());
+      continue;
+    }
+
+    const matchingMarkers = [...markersById.values()]
+      .filter(
+        (marker) =>
+          (!selector.compositionId ||
+            marker.compositionId === selector.compositionId) &&
+          (!selector.gitSha || marker.gitSha === selector.gitSha) &&
+          (!selector.gateFingerprint ||
+            marker.gateFingerprint === selector.gateFingerprint) &&
+          (!selector.configFingerprint ||
+            marker.configFingerprint === selector.configFingerprint) &&
+          (!selector.contextFingerprint ||
+            marker.contextFingerprint === selector.contextFingerprint) &&
+          marker.timestamp >= startTime &&
+          marker.timestamp < endTime,
+      )
+      .sort(
+        (left, right) =>
+          left.timestamp - right.timestamp ||
+          left.type.localeCompare(right.type) ||
+          left.id.localeCompare(right.id),
+      );
+    let lastLossValue: number | null | undefined;
+    let hasLastLossValue = false;
+    const markers = matchingMarkers.filter((marker) => {
+      if (marker.type !== 'L') return true;
+      if (hasLastLossValue && marker.maxLossValue === lastLossValue) {
+        return false;
+      }
+      hasLastLossValue = true;
+      lastLossValue = marker.maxLossValue;
+      return true;
+    });
+    if (
+      !markers.length &&
+      (selector.compositionId ||
+        selector.gitSha ||
+        selector.gateFingerprint ||
+        selector.configFingerprint ||
+        selector.contextFingerprint)
+    ) {
+      continue;
+    }
+    timelines.set(selectorKey, {
+      status: 'verified',
+      observedFrom: markers.length
+        ? Math.min(...markers.map((marker) => marker.timestamp))
+        : Math.min(...envelopes.map((envelope) => envelope.payload.createdAt)),
+      markers,
+    });
+  }
+
+  return timelines;
+};