@tradejs/app 3.1.0 → 3.1.1

package/README.md

@@ -42,3 +42,5 @@ before starting or building the app with:
 ```bash
 NEXT_PUBLIC_TRADEJS_TELEMETRY_DISABLED=1
 ```
+
+Keywords: ai, claude, codex.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/app",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Installable Next.js UI for the TradeJS TypeScript framework: dashboards, backtests, charts, and runtime data.",
   "keywords": [
     "tradejs",
@@ -9,7 +9,10 @@
     "app",
     "dashboard",
     "nextjs",
-    "signals"
+    "signals",
+    "ai",
+    "claude",
+    "codex"
   ],
   "files": [
     "README.md",
@@ -49,11 +52,11 @@
     "@chakra-ui/charts": "3.36.1",
     "@chakra-ui/react": "3.36.1",
     "@emotion/react": "^11.14.0",
-    "@tradejs/core": "^3.1.0",
-    "@tradejs/indicators": "^3.1.0",
-    "@tradejs/infra": "^3.1.0",
-    "@tradejs/node": "^3.1.0",
-    "@tradejs/types": "^3.1.0",
+    "@tradejs/core": "^3.1.1",
+    "@tradejs/indicators": "^3.1.1",
+    "@tradejs/infra": "^3.1.1",
+    "@tradejs/node": "^3.1.1",
+    "@tradejs/types": "^3.1.1",
     "@types/bcryptjs": "2.4.6",
     "@types/lodash": "4.17.24",
     "@types/node": "24.13.3",

package/src/app/api/user/runtime-deployments/[deploymentId]/strategies/[strategyName]/control/route.ts

@@ -0,0 +1,73 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  getRuntimeDeployment,
+  saveRuntimeDeployment,
+} from '@tradejs/infra/runtimeDeployments';
+import { recordRuntimeStrategyControlEvent } from '@tradejs/infra/runtimeStrategyReleases';
+import type { RuntimeStrategyControlState } from '@tradejs/types';
+import { getCurrentUserName } from '#app/lib/currentUser';
+
+export const PATCH = async (
+  request: NextRequest,
+  {
+    params,
+  }: {
+    params: Promise<{ deploymentId: string; strategyName: string }>;
+  },
+) => {
+  const userName = await getCurrentUserName();
+  if (!userName) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  }
+  const { deploymentId, strategyName: encodedStrategyName } = await params;
+  const strategyName = decodeURIComponent(encodedStrategyName);
+  const deployment = await getRuntimeDeployment(userName, deploymentId);
+  if (!deployment) {
+    return NextResponse.json(
+      { error: 'Deployment not found' },
+      { status: 404 },
+    );
+  }
+  const body = (await request.json()) as { controlState?: unknown };
+  if (
+    body.controlState !== 'active' &&
+    body.controlState !== 'entries_paused'
+  ) {
+    return NextResponse.json(
+      { error: 'controlState must be active or entries_paused' },
+      { status: 400 },
+    );
+  }
+  const controlState: RuntimeStrategyControlState = body.controlState;
+  const reference = deployment.strategies.find(
+    (strategy) => strategy.strategyName === strategyName,
+  );
+  if (!reference?.releaseVersion) {
+    return NextResponse.json(
+      { error: 'Pause/resume requires a versioned strategy release' },
+      { status: 400 },
+    );
+  }
+  const previousState = reference.controlState ?? 'active';
+  if (previousState === controlState) {
+    return NextResponse.json({ deployment, controlState });
+  }
+  const updated = await saveRuntimeDeployment(userName, {
+    ...deployment,
+    strategies: deployment.strategies.map((strategy) =>
+      strategy.strategyName === strategyName
+        ? { ...strategy, controlState }
+        : strategy,
+    ),
+  });
+  const event = await recordRuntimeStrategyControlEvent({
+    userName,
+    deploymentId: deployment.id,
+    strategyName,
+    releaseVersion: reference.releaseVersion,
+    previousState,
+    nextState: controlState,
+    createdBy: userName,
+  });
+  return NextResponse.json({ deployment: updated, controlState, event });
+};

package/src/app/api/user/runtime-deployments/route.ts

@@ -5,6 +5,7 @@ import {
   saveRuntimeDeployment,
 } from '@tradejs/infra/runtimeDeployments';
 import { getTradingAccount } from '@tradejs/infra/tradingAccounts';
+import { getRuntimeStrategyRelease } from '@tradejs/infra/runtimeStrategyReleases';
 import { isMarketUniverse, type RuntimeDeployment } from '@tradejs/types';
 import { getCurrentUserName } from '#app/lib/currentUser';
 
@@ -32,21 +33,59 @@ export const POST = async (request: NextRequest) => {
   }
   try {
     const body = (await request.json()) as Partial<RuntimeDeployment>;
-    const universe = body.universe;
+    const hasVersionedStrategies = Boolean(
+      body.strategies?.some((strategy) => strategy.releaseVersion != null),
+    );
+    if (
+      hasVersionedStrategies &&
+      body.strategies?.some((strategy) => strategy.releaseVersion == null)
+    ) {
+      return NextResponse.json(
+        { error: 'A deployment cannot mix legacy configs and releases' },
+        { status: 400 },
+      );
+    }
+    const releases = hasVersionedStrategies
+      ? await Promise.all(
+          (body.strategies ?? []).map(async (strategy) => {
+            if (
+              !Number.isSafeInteger(strategy.releaseVersion) ||
+              !strategy.releaseVersion ||
+              (strategy.config && Object.keys(strategy.config).length)
+            ) {
+              throw new Error('Invalid versioned strategy reference');
+            }
+            const release = await getRuntimeStrategyRelease(
+              userName,
+              strategy.strategyName,
+              strategy.releaseVersion,
+            );
+            if (!release) {
+              throw new Error(
+                `Release not found: ${strategy.strategyName} v${strategy.releaseVersion}`,
+              );
+            }
+            return release;
+          }),
+        )
+      : [];
+    const universe = releases[0]?.config.UNIVERSE ?? body.universe;
+    const interval = releases[0]?.config.INTERVAL ?? body.interval;
     if (
       !body.id ||
       !body.label ||
       !body.connectorName ||
       !body.provider ||
       !body.accountId ||
-      !body.interval ||
+      !interval ||
       !isMarketUniverse(universe) ||
       !Array.isArray(body.strategies) ||
       !body.strategies.length ||
-      body.strategies.some(
-        (strategy) =>
-          !String(strategy.strategyName ?? '').trim() ||
-          !String(strategy.policyProfileId ?? '').trim(),
+      body.strategies.some((strategy) =>
+        hasVersionedStrategies
+          ? !String(strategy.strategyName ?? '').trim()
+          : !String(strategy.strategyName ?? '').trim() ||
+            !String(strategy.policyProfileId ?? '').trim(),
       )
     ) {
       return NextResponse.json(
@@ -78,9 +117,17 @@ export const POST = async (request: NextRequest) => {
       provider: body.provider,
       accountId: body.accountId,
       universe,
-      interval: String(body.interval),
+      interval: String(interval),
       enabled: body.enabled !== false,
-      strategies: body.strategies,
+      strategies: body.strategies.map((strategy) =>
+        hasVersionedStrategies
+          ? {
+              strategyName: strategy.strategyName,
+              releaseVersion: strategy.releaseVersion,
+              controlState: strategy.controlState ?? 'active',
+            }
+          : strategy,
+      ),
       assetClasses: body.assetClasses,
       tickers: body.tickers,
     });

package/src/app/api/user/runtime-strategy-releases/route.ts

@@ -0,0 +1,60 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  getRuntimeStrategyReleaseOptions,
+  publishRuntimeStrategyReleaseForUser,
+  saveRuntimeStrategyReleaseDraftForUser,
+} from '#app/lib/runtimeStrategyReleaseService';
+import { getCurrentUserName } from '#app/lib/currentUser';
+
+export const dynamic = 'force-dynamic';
+
+const projectRoot =
+  String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+
+export const GET = async () => {
+  const userName = await getCurrentUserName();
+  if (!userName)
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  return NextResponse.json(
+    await getRuntimeStrategyReleaseOptions({ userName, projectRoot }),
+  );
+};
+
+export const PATCH = async (request: NextRequest) => {
+  const userName = await getCurrentUserName();
+  if (!userName)
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  try {
+    const draft = await saveRuntimeStrategyReleaseDraftForUser({
+      userName,
+      projectRoot,
+      input: (await request.json()) as Record<string, unknown>,
+    });
+    return NextResponse.json({ draft });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 400 },
+    );
+  }
+};
+
+export const POST = async (request: NextRequest) => {
+  const userName = await getCurrentUserName();
+  if (!userName)
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+  try {
+    const body = (await request.json()) as { strategyName?: unknown };
+    const release = await publishRuntimeStrategyReleaseForUser({
+      userName,
+      projectRoot,
+      strategyName: String(body.strategyName ?? '').trim(),
+    });
+    return NextResponse.json({ release });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : String(error) },
+      { status: 400 },
+    );
+  }
+};

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

@@ -26,6 +26,7 @@ import {
   getColorByLevel,
   RUNTIME_ORDER_ROW_HEIGHT,
 } from './RuntimeStrategyCard.presenter';
+import { toaster } from '#ui';
 
 const StatItem = ({
   stat,
@@ -64,11 +65,42 @@ export const RuntimeStrategyCard = ({
   const [configOpen, setConfigOpen] = useState(false);
   const [ordersOpen, setOrdersOpen] = useState(false);
   const [statsOpen, setStatsOpen] = useState(false);
+  const [controlSaving, setControlSaving] = useState(false);
   const viewModel = useMemo(
     () => buildRuntimeStrategyCardViewModel(strategy),
     [strategy],
   );
   const { lastTrade, runtimeOrders } = viewModel;
+  const setControlState = async (controlState: 'active' | 'entries_paused') => {
+    if (!strategy.deploymentId || !strategy.releaseVersion) return;
+    setControlSaving(true);
+    try {
+      const response = await fetch(
+        `/api/user/runtime-deployments/${encodeURIComponent(strategy.deploymentId)}/strategies/${encodeURIComponent(strategy.strategyName)}/control`,
+        {
+          method: 'PATCH',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ controlState }),
+        },
+      );
+      const payload = (await response.json()) as { error?: string };
+      if (!response.ok) throw new Error(payload.error || 'Update failed');
+      toaster.success({
+        title:
+          controlState === 'entries_paused'
+            ? 'New entries paused'
+            : 'Strategy resumed',
+      });
+      await onUpdated();
+    } catch (error) {
+      toaster.error({
+        title: 'Could not update strategy state',
+        description: error instanceof Error ? error.message : String(error),
+      });
+    } finally {
+      setControlSaving(false);
+    }
+  };
 
   return (
     <Box
@@ -91,7 +123,11 @@ export const RuntimeStrategyCard = ({
           fontFamily="mono"
           letterSpacing="0"
         >
-          {strategy.enabled ? 'enabled' : 'disabled'}
+          {strategy.controlState === 'entries_paused'
+            ? 'entries paused'
+            : strategy.enabled
+              ? 'enabled'
+              : 'disabled'}
         </Badge>
         <Badge colorPalette="blue" variant="outline">
           {strategy.universe}
@@ -99,9 +135,15 @@ export const RuntimeStrategyCard = ({
         <Badge colorPalette="cyan" variant="outline">
           TF: {strategy.interval}m
         </Badge>
-        <Badge colorPalette="gray" variant="outline">
-          config: {strategy.configId}
-        </Badge>
+        {strategy.releaseVersion ? (
+          <Badge colorPalette="gray" variant="outline">
+            release: v{strategy.releaseVersion}
+          </Badge>
+        ) : (
+          <Badge colorPalette="gray" variant="outline">
+            legacy config: {strategy.configId}
+          </Badge>
+        )}
         {strategy.accountId ? (
           <Badge colorPalette="purple" variant="outline">
             account: {strategy.accountLabel ?? strategy.accountId}
@@ -171,7 +213,24 @@ export const RuntimeStrategyCard = ({
                 <Menu.Content minW="160px">
                   {strategy.connected ? (
                     <Menu.Item value="edit" onClick={() => setConfigOpen(true)}>
-                      Edit
+                      {strategy.releaseVersion ? 'View config' : 'Edit'}
+                    </Menu.Item>
+                  ) : null}
+                  {strategy.releaseVersion && strategy.deploymentId ? (
+                    <Menu.Item
+                      value="control"
+                      disabled={controlSaving}
+                      onClick={() =>
+                        void setControlState(
+                          strategy.controlState === 'entries_paused'
+                            ? 'active'
+                            : 'entries_paused',
+                        )
+                      }
+                    >
+                      {strategy.controlState === 'entries_paused'
+                        ? 'Resume entries'
+                        : 'Pause new entries'}
                     </Menu.Item>
                   ) : null}
                   <Menu.Item value="orders" onClick={() => setOrdersOpen(true)}>

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

@@ -160,7 +160,7 @@ export const RuntimeStrategyConfigDrawer = ({
       setMlThreshold(String(managed.mlThreshold));
       setParameters('{}');
     }
-    void loadOptions();
+    if (!strategy?.releaseVersion) void loadOptions();
   }, [loadOptions, open, strategy]);
 
   const compatibleAccounts = useMemo(
@@ -251,6 +251,50 @@ export const RuntimeStrategyConfigDrawer = ({
     }
   };
 
+  if (strategy?.releaseVersion) {
+    return (
+      <Drawer.Root
+        size="lg"
+        open={open}
+        onOpenChange={(event) => onOpenChange(event.open)}
+      >
+        <Portal>
+          <Drawer.Backdrop />
+          <Drawer.Positioner>
+            <Drawer.Content bg="gray.950">
+              <Drawer.Header>
+                <Drawer.Title>
+                  {strategy.strategyName} release v{strategy.releaseVersion}
+                </Drawer.Title>
+                <Drawer.CloseTrigger asChild>
+                  <CloseButton size="sm" />
+                </Drawer.CloseTrigger>
+              </Drawer.Header>
+              <Drawer.Body display="flex" flexDirection="column" gap={4}>
+                <Text color="gray.400">
+                  Published releases are immutable. Create and publish a new
+                  release to change this configuration.
+                </Text>
+                <Textarea
+                  value={JSON.stringify(strategy.config ?? {}, null, 2)}
+                  readOnly
+                  minH="70vh"
+                  fontFamily="mono"
+                  fontSize="sm"
+                />
+              </Drawer.Body>
+              <Drawer.Footer>
+                <Button variant="outline" onClick={() => onOpenChange(false)}>
+                  Close
+                </Button>
+              </Drawer.Footer>
+            </Drawer.Content>
+          </Drawer.Positioner>
+        </Portal>
+      </Drawer.Root>
+    );
+  }
+
   return (
     <Drawer.Root
       size="lg"

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

@@ -137,7 +137,9 @@ export const StrategyEvidencePopover = ({
                           )}.`
                       : 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.'}
+                        : timeline.status === 'not_attached'
+                          ? 'The runtime release is published, but no checksum-verified research artifact is attached yet.'
+                          : 'No checksum-verified evidence artifact is available. No mutable fallback is used.'}
                   </Text>
                 </Box>
 

package/src/app/lib/runtimeStrategyReleaseService.ts

@@ -0,0 +1,123 @@
+import {
+  getRuntimeStrategyDraft,
+  listRuntimeStrategyReleases,
+  publishRuntimeStrategyRelease,
+  saveRuntimeStrategyDraft,
+} from '@tradejs/infra/runtimeStrategyReleases';
+import { getRuntimeStrategyPackageMetadata } from '@tradejs/node/runtimeStrategies';
+import {
+  getAvailableStrategyNames,
+  getStrategyDefaults,
+} from '@tradejs/node/strategies';
+import type { StrategyConfig } from '@tradejs/types';
+
+const OPERATIONAL_KEYS = [
+  'ACCOUNT_ID',
+  'AI_REPLAY_ANALYSES',
+  'DEPLOYMENT_ID',
+  'ENABLE',
+  'ENV',
+  'MAKE_ORDERS',
+  'RECORD_RUNTIME_TRADES',
+  'configId',
+];
+
+const assertConfig = (value: unknown): StrategyConfig => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('Strategy config must be a JSON object');
+  }
+  const config = value as StrategyConfig;
+  const invalidKey = OPERATIONAL_KEYS.find((key) => config[key] !== undefined);
+  if (invalidKey) {
+    throw new Error(
+      `${invalidKey} is controlled by the deployment, not config`,
+    );
+  }
+  return config;
+};
+
+const assertKnownStrategy = async (
+  strategyName: string,
+  projectRoot: string,
+) => {
+  if (!(await getAvailableStrategyNames(projectRoot)).includes(strategyName)) {
+    throw new Error(`Unknown strategy: ${strategyName}`);
+  }
+};
+
+export const getRuntimeStrategyReleaseOptions = async ({
+  userName,
+  projectRoot,
+}: {
+  userName: string;
+  projectRoot: string;
+}) => {
+  const strategyNames = await getAvailableStrategyNames(projectRoot);
+  const strategies = await Promise.all(
+    strategyNames.map(async (strategyName) => ({
+      strategyName,
+      draft: await getRuntimeStrategyDraft(userName, strategyName),
+      releases: await listRuntimeStrategyReleases(userName, strategyName),
+    })),
+  );
+  return { strategyNames, strategies };
+};
+
+export const saveRuntimeStrategyReleaseDraftForUser = async ({
+  userName,
+  projectRoot,
+  input,
+}: {
+  userName: string;
+  projectRoot: string;
+  input: Record<string, unknown>;
+}) => {
+  const strategyName = String(input.strategyName ?? '').trim();
+  await assertKnownStrategy(strategyName, projectRoot);
+  return saveRuntimeStrategyDraft({
+    userName,
+    strategyName,
+    config: assertConfig(input.config),
+    baseReleaseVersion:
+      typeof input.baseReleaseVersion === 'number'
+        ? input.baseReleaseVersion
+        : null,
+    updatedBy: userName,
+  });
+};
+
+export const publishRuntimeStrategyReleaseForUser = async ({
+  userName,
+  projectRoot,
+  strategyName,
+}: {
+  userName: string;
+  projectRoot: string;
+  strategyName: string;
+}) => {
+  await assertKnownStrategy(strategyName, projectRoot);
+  const draft = await getRuntimeStrategyDraft(userName, strategyName);
+  if (!draft) throw new Error(`Draft not found: ${strategyName}`);
+  const defaults = (await getStrategyDefaults(strategyName, projectRoot)) ?? {};
+  const config: StrategyConfig = { ...defaults, ...draft.config };
+  for (const key of OPERATIONAL_KEYS) delete config[key];
+  const metadata = await getRuntimeStrategyPackageMetadata({
+    strategyName,
+    projectRoot,
+  });
+  const release = await publishRuntimeStrategyRelease({
+    userName,
+    strategyName,
+    config,
+    ...metadata,
+    createdBy: userName,
+  });
+  await saveRuntimeStrategyDraft({
+    userName,
+    strategyName,
+    config: release.config,
+    baseReleaseVersion: release.releaseVersion,
+    updatedBy: userName,
+  });
+  return release;
+};

package/src/app/routes/strategies/StrategiesPageClient.tsx

@@ -1,7 +1,7 @@
 'use client';
 
 import { Suspense, useCallback, useEffect, useMemo, useState } from 'react';
-import { Box, Button, ClientOnly, Flex } from '@chakra-ui/react';
+import { Box, ClientOnly, Flex } from '@chakra-ui/react';
 import { usePathname } from 'next/navigation';
 import { FiFolder } from 'react-icons/fi';
 import type {
@@ -16,7 +16,6 @@ import {
 } from '#actions/strategies';
 import { RuntimeStrategyCard } from '#components/Strategies/RuntimeStrategyCard';
 import { RuntimeStrategyCardSkeleton } from '#components/Strategies/RuntimeStrategyCardSkeleton';
-import { RuntimeStrategyConfigDrawer } from '#components/Strategies/RuntimeStrategyConfigDrawer';
 import { StrategySnapshotList } from '#components/Strategies/StrategySnapshotList';
 import { BacktestResultsPageClient } from '#components/Backtest/ResultsPageClient';
 import {
@@ -85,7 +84,6 @@ const RuntimeStrategiesContent = () => {
   const [error, setError] = useState('');
   const [runtimeData, setRuntimeData] =
     useState<RuntimeStrategiesResponse | null>(null);
-  const [createRuntimeConfigOpen, setCreateRuntimeConfigOpen] = useState(false);
   const [snapshotData, setSnapshotData] =
     useState<StrategyChartsSnapshotResponse | null>(null);
   const isSnapshotMode = mode === 'replay' || mode === 'ai';
@@ -519,23 +517,8 @@ const RuntimeStrategiesContent = () => {
                   />
                 ) : null}
               </Flex>
-              {mode === 'runtime' ? (
-                <Button
-                  ml="auto"
-                  colorPalette="teal"
-                  onClick={() => setCreateRuntimeConfigOpen(true)}
-                >
-                  Create
-                </Button>
-              ) : null}
             </Flex>
 
-            <RuntimeStrategyConfigDrawer
-              open={createRuntimeConfigOpen}
-              onOpenChange={setCreateRuntimeConfigOpen}
-              onSaved={load}
-            />
-
             {isSnapshotMode ? (
               <BulkDeleteToolbar
                 selectedCount={selectedFilteredCount}