@tradejs/cli 3.1.21-beta.237 → 3.1.22-beta.238

package/dist/cli.js

@@ -255,7 +255,7 @@ var init_researchRoots = __esm({
     resolveResearchRoots = (options = {}) => {
       const cwd = import_node_path.default.resolve(options.cwd || process.cwd());
       const env = options.env || process.env;
-      const projectRoot15 = import_node_path.default.resolve(
+      const projectRoot17 = import_node_path.default.resolve(
         firstNonEmpty(options.projectRoot, env.PROJECT_CWD, cwd) || cwd
       );
       const sourceRepositoryRoot = firstNonEmpty(
@@ -263,7 +263,7 @@ var init_researchRoots = __esm({
         env[SOURCE_REPOSITORY_ROOT_ENV]
       );
       return {
-        projectRoot: projectRoot15,
+        projectRoot: projectRoot17,
         ...sourceRepositoryRoot ? { sourceRepositoryRoot: import_node_path.default.resolve(sourceRepositoryRoot) } : {}
       };
     };
@@ -1943,32 +1943,32 @@ var init_commandOptions = __esm({
       (arg) => arg === `--${longName}` || arg.startsWith(`--${longName}=`) || (shortName ? arg === `-${shortName}` : false)
     );
     resolveAiPocketSearchCommandOptions = ({
-      flags: flags32,
+      flags: flags34,
       argv: argv2
     }) => {
-      const outDir = String(flags32.outDir || "data/ai/export");
-      const strategyName = String(flags32.strategy || "").trim() || void 0;
-      const explicitFile = String(flags32.file || "").trim();
-      const skip = normalizeInt(flags32.skip, 0);
-      const minQuality = normalizeInt(flags32.minQuality, 4);
-      const sinceInput = parseTimestampFilter(flags32.since);
-      const untilTimestamp = parseTimestampFilter(flags32.until);
-      const trailingPeriodMs = parseTrailingPeriodMs(flags32.period);
-      const periodLabel = String(flags32.period || "").trim() || null;
+      const outDir = String(flags34.outDir || "data/ai/export");
+      const strategyName = String(flags34.strategy || "").trim() || void 0;
+      const explicitFile = String(flags34.file || "").trim();
+      const skip = normalizeInt(flags34.skip, 0);
+      const minQuality = normalizeInt(flags34.minQuality, 4);
+      const sinceInput = parseTimestampFilter(flags34.since);
+      const untilTimestamp = parseTimestampFilter(flags34.until);
+      const trailingPeriodMs = parseTrailingPeriodMs(flags34.period);
+      const periodLabel = String(flags34.period || "").trim() || null;
       const hasDateFilter = trailingPeriodMs != null || sinceInput != null || untilTimestamp != null;
       const recent = resolveAiTrainRecentLimit({
         argv: argv2,
-        recentValue: flags32.recent,
+        recentValue: flags34.recent,
         hasDateFilter
       });
-      const qualityThresholds = parseQualityThresholds(flags32.qualityThresholds);
-      const scope = String(flags32.scope || "all").trim().toLowerCase();
+      const qualityThresholds = parseQualityThresholds(flags34.qualityThresholds);
+      const scope = String(flags34.scope || "all").trim().toLowerCase();
       if (!["all", "approved", "rejected", "candidates"].includes(scope)) {
         throw new Error(
           `Unsupported --scope "${scope}". Use all, approved, rejected, or candidates.`
         );
       }
-      const direction = String(flags32.direction || "").trim().toUpperCase();
+      const direction = String(flags34.direction || "").trim().toUpperCase();
       if (direction && !["LONG", "SHORT"].includes(direction)) {
         throw new Error(
           `Unsupported --direction "${direction}". Use LONG or SHORT.`
@@ -1979,14 +1979,14 @@ var init_commandOptions = __esm({
         "maxEventCountShare",
         "U"
       );
-      const maxDepth = normalizePositiveInt(flags32.maxDepth, 2);
-      const explicitMinSupport = hasCliOption2(argv2, "minSupport", "m") ? normalizePositiveInt(flags32.minSupport, 20) : void 0;
+      const maxDepth = normalizePositiveInt(flags34.maxDepth, 2);
+      const explicitMinSupport = hasCliOption2(argv2, "minSupport", "m") ? normalizePositiveInt(flags34.minSupport, 20) : void 0;
       const minProfitFactor = normalizeNonNegativeNumber(
         readAiPocketSearchCliOption({
           argv: argv2,
           longName: "minProfitFactor",
           shortName: "F"
-        }) ?? flags32.minProfitFactor,
+        }) ?? flags34.minProfitFactor,
         1.2
       );
       const minWinRate = normalizeNonNegativeNumber(
@@ -1994,21 +1994,21 @@ var init_commandOptions = __esm({
           argv: argv2,
           longName: "minWinRate",
           shortName: "W"
-        }) ?? flags32.minWinRate,
+        }) ?? flags34.minWinRate,
         0
       );
       const minTotalProfitValue = readAiPocketSearchCliOption({
         argv: argv2,
         longName: "minTotalProfit",
         shortName: "R"
-      }) ?? flags32.minTotalProfit;
+      }) ?? flags34.minTotalProfit;
       const minTotalProfit = Number.isFinite(Number(minTotalProfitValue)) ? Number(minTotalProfitValue) : 0;
       const validationSplit = hasCliOption2(argv2, "validationSplit", "V") ? normalizeRatio(
         readAiPocketSearchCliOption({
           argv: argv2,
           longName: "validationSplit",
           shortName: "V"
-        }) ?? flags32.validationSplit,
+        }) ?? flags34.validationSplit,
         0.25
       ) : 0.25;
       const testSplit = hasCliOption2(argv2, "testSplit", "T") ? normalizeRatio(
@@ -2016,10 +2016,10 @@ var init_commandOptions = __esm({
           argv: argv2,
           longName: "testSplit",
           shortName: "T"
-        }) ?? flags32.testSplit,
+        }) ?? flags34.testSplit,
         0
       ) : 0;
-      const sealTest = Boolean(flags32.sealTest);
+      const sealTest = Boolean(flags34.sealTest);
       if (sealTest && testSplit <= 0) {
         throw new Error("--sealTest requires a positive --testSplit");
       }
@@ -2028,7 +2028,7 @@ var init_commandOptions = __esm({
           argv: argv2,
           longName: "maxEventCountShare",
           shortName: "U"
-        }) ?? flags32.maxEventCountShare,
+        }) ?? flags34.maxEventCountShare,
         0.25
       );
       const maxSymbolCountShare = normalizeUnitRatio(
@@ -2036,10 +2036,10 @@ var init_commandOptions = __esm({
           argv: argv2,
           longName: "maxSymbolCountShare",
           shortName: "Z"
-        }) ?? flags32.maxSymbolCountShare,
+        }) ?? flags34.maxSymbolCountShare,
         0.5
       );
-      const objective = normalizeObjective(flags32.objective, scope);
+      const objective = normalizeObjective(flags34.objective, scope);
       return {
         outDir,
         strategyName,
@@ -2059,33 +2059,33 @@ var init_commandOptions = __esm({
         minProfitFactor,
         minWinRate,
         minTotalProfit,
-        maxAtomicPredicates: normalizePositiveInt(flags32.maxAtomicPredicates, 180),
-        maxCombinations: normalizePositiveInt(flags32.maxCombinations, 6e4),
+        maxAtomicPredicates: normalizePositiveInt(flags34.maxAtomicPredicates, 180),
+        maxCombinations: normalizePositiveInt(flags34.maxCombinations, 6e4),
         validationSplit,
         testSplit,
         sealTest,
-        explicitMinValidationSupport: normalizeInt(flags32.minValidationSupport, 0),
-        explicitMinEvents: normalizeInt(flags32.minEvents, 0),
-        explicitMinValidationEvents: normalizeInt(flags32.minValidationEvents, 0),
-        maxBatch: normalizeInt(flags32.maxBatch, 5),
+        explicitMinValidationSupport: normalizeInt(flags34.minValidationSupport, 0),
+        explicitMinEvents: normalizeInt(flags34.minEvents, 0),
+        explicitMinValidationEvents: normalizeInt(flags34.minValidationEvents, 0),
+        maxBatch: normalizeInt(flags34.maxBatch, 5),
         maxEventCountShare,
         explicitMaxEventCountShare,
         maxSymbolCountShare,
         objective,
-        allowRiskRegression: Boolean(flags32.allowRiskRegression),
-        requireValidationEligibility: !Boolean(flags32.allowValidationRegression),
-        dedupeEquivalentSelections: Boolean(flags32.dedupeEquivalentSelections),
-        top: normalizePositiveInt(flags32.top, 30),
-        includeSymbol: Boolean(flags32.includeSymbol),
-        includeGateContext: Boolean(flags32.includeGateContext),
-        featureProfile: normalizeFeatureProfile(flags32.featureProfile),
-        featurePolicy: normalizeFeaturePolicy(flags32.featurePolicy),
-        coverageMode: normalizeCoverageMode(flags32.coverageMode),
-        cadenceMode: normalizeCadenceMode(flags32.cadenceMode),
-        jsonOutput: Boolean(flags32.json),
-        outputPath: String(flags32.output || "").trim(),
-        reportDir: String(flags32.reportDir || "data/ai/output").trim(),
-        explicitReportFile: String(flags32.reportFile || "").trim()
+        allowRiskRegression: Boolean(flags34.allowRiskRegression),
+        requireValidationEligibility: !Boolean(flags34.allowValidationRegression),
+        dedupeEquivalentSelections: Boolean(flags34.dedupeEquivalentSelections),
+        top: normalizePositiveInt(flags34.top, 30),
+        includeSymbol: Boolean(flags34.includeSymbol),
+        includeGateContext: Boolean(flags34.includeGateContext),
+        featureProfile: normalizeFeatureProfile(flags34.featureProfile),
+        featurePolicy: normalizeFeaturePolicy(flags34.featurePolicy),
+        coverageMode: normalizeCoverageMode(flags34.coverageMode),
+        cadenceMode: normalizeCadenceMode(flags34.cadenceMode),
+        jsonOutput: Boolean(flags34.json),
+        outputPath: String(flags34.output || "").trim(),
+        reportDir: String(flags34.reportDir || "data/ai/output").trim(),
+        explicitReportFile: String(flags34.reportFile || "").trim()
       };
     };
   }
@@ -2185,9 +2185,9 @@ var init_features = __esm({
       "targetsymbol",
       "universe"
     ]);
-    normalizeFeaturePath = (path35) => (Array.isArray(path35) ? path35 : path35.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
-    classifyAiPocketCoverageFeaturePath = (path35) => {
-      const segments = normalizeFeaturePath(path35);
+    normalizeFeaturePath = (path41) => (Array.isArray(path41) ? path41 : path41.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
+    classifyAiPocketCoverageFeaturePath = (path41) => {
+      const segments = normalizeFeaturePath(path41);
       const normalizedPath = segments.join(".");
       if (segments.some(
         (segment) => segment.includes("cmc") || segment.includes("coinmarketcap")
@@ -2361,8 +2361,8 @@ var init_features = __esm({
       "volumeusd",
       "vwap"
     ]);
-    classifyAiPocketFeaturePath = (path35) => {
-      const segments = (Array.isArray(path35) ? path35 : path35.split(".")).filter(
+    classifyAiPocketFeaturePath = (path41) => {
+      const segments = (Array.isArray(path41) ? path41 : path41.split(".")).filter(
         Boolean
       );
       const normalized = segments.map((segment) => segment.toLowerCase());
@@ -5988,10 +5988,10 @@ var init_command = __esm({
     init_dataset();
     init_research();
     runAiPocketSearchCommand = async ({
-      flags: flags32
+      flags: flags34
     }) => {
       const options = resolveAiPocketSearchCommandOptions({
-        flags: flags32,
+        flags: flags34,
         argv: process.argv
       });
       const {
@@ -6896,11 +6896,11 @@ var init_strategyGateFingerprint = __esm({
       "@tradejs/core/strategies"
     ];
     resolveStrategyGateFingerprint = async ({
-      projectRoot: projectRoot15,
+      projectRoot: projectRoot17,
       strategyName,
       gitSha
     }) => {
-      const projectManifestPath = import_node_path3.default.join(projectRoot15, "package.json");
+      const projectManifestPath = import_node_path3.default.join(projectRoot17, "package.json");
       const projectExists = await import_promises6.default.access(projectManifestPath).then(() => true).catch(() => false);
       const requireFromProject = projectExists ? (0, import_node_module.createRequire)(projectManifestPath) : null;
       const candidates = requireFromProject ? await Promise.all(
@@ -7079,10 +7079,10 @@ var init_aiTrainResearch = __esm({
         };
       });
     };
-    getGitLineage = (projectRoot15) => {
+    getGitLineage = (projectRoot17) => {
       try {
         const gitSha = (0, import_node_child_process2.execFileSync)("git", ["rev-parse", "HEAD"], {
-          cwd: projectRoot15,
+          cwd: projectRoot17,
           encoding: "utf8",
           stdio: ["ignore", "pipe", "ignore"]
         }).trim();
@@ -7090,7 +7090,7 @@ var init_aiTrainResearch = __esm({
           "git",
           ["status", "--porcelain", "--untracked-files=no"],
           {
-            cwd: projectRoot15,
+            cwd: projectRoot17,
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"]
           }
@@ -7101,16 +7101,16 @@ var init_aiTrainResearch = __esm({
       }
     };
     buildAiTrainLineage = async ({
-      projectRoot: projectRoot15,
+      projectRoot: projectRoot17,
       strategyName,
       configIds,
       runContext,
       sourceSha256s = [],
       env = process.env
     }) => {
-      const { gitSha, gitDirty } = getGitLineage(projectRoot15);
+      const { gitSha, gitDirty } = getGitLineage(projectRoot17);
       const gate = await resolveStrategyGateFingerprint({
-        projectRoot: projectRoot15,
+        projectRoot: projectRoot17,
         strategyName,
         gitSha
       });
@@ -9141,12 +9141,12 @@ var init_binanceMarketContextBackfill = __esm({
       return rows;
     };
     getBinanceConnector = async ({
-      projectRoot: projectRoot15,
+      projectRoot: projectRoot17,
       userName: userName3
     }) => {
       const creator = await (0, import_connectors2.getConnectorCreatorByName)(
         import_connectors.ConnectorNames.Binance,
-        projectRoot15
+        projectRoot17
       );
       if (!creator) {
         throw new Error(
@@ -10693,27 +10693,27 @@ var init_coinMarketCapContextBackfill = __esm({
       totalCredits: 0,
       byPath: /* @__PURE__ */ new Map()
     });
-    getCoinMarketCapPathLabel = (path35) => {
-      if (path35.includes("global-metrics")) return "global";
-      if (path35.includes("cryptocurrency/quotes")) return "reference";
-      if (path35.includes("exchange/quotes")) return "exchangeLiquidity";
-      if (path35.includes("fear-and-greed")) return "fearGreed";
-      if (path35.includes("cmc100")) return "cmc100";
-      if (path35.includes("cmc20")) return "cmc20";
-      return path35;
-    };
-    recordCoinMarketCapFetchStats = (stats, path35, creditCount) => {
+    getCoinMarketCapPathLabel = (path41) => {
+      if (path41.includes("global-metrics")) return "global";
+      if (path41.includes("cryptocurrency/quotes")) return "reference";
+      if (path41.includes("exchange/quotes")) return "exchangeLiquidity";
+      if (path41.includes("fear-and-greed")) return "fearGreed";
+      if (path41.includes("cmc100")) return "cmc100";
+      if (path41.includes("cmc20")) return "cmc20";
+      return path41;
+    };
+    recordCoinMarketCapFetchStats = (stats, path41, creditCount) => {
       if (!stats) return;
-      const existing = stats.byPath.get(path35) ?? { requests: 0, credits: 0 };
+      const existing = stats.byPath.get(path41) ?? { requests: 0, credits: 0 };
       existing.requests += 1;
       existing.credits += creditCount ?? 0;
       stats.requests += 1;
       stats.totalCredits += creditCount ?? 0;
-      stats.byPath.set(path35, existing);
+      stats.byPath.set(path41, existing);
     };
     formatCoinMarketCapFetchStats = (stats) => {
       const byPath = [...stats.byPath.entries()].map(
-        ([path35, item]) => `${getCoinMarketCapPathLabel(path35)}=${item.requests}req/${item.credits}cr`
+        ([path41, item]) => `${getCoinMarketCapPathLabel(path41)}=${item.requests}req/${item.credits}cr`
       ).join(" ");
       return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
     };
@@ -12471,7 +12471,7 @@ var init_historyPrepare = __esm({
       connectorName,
       marketConnector,
       userName: userName3,
-      projectRoot: projectRoot15,
+      projectRoot: projectRoot17,
       shouldUseDedicatedReferences,
       requireDedicatedReferences = false,
       warn
@@ -12483,8 +12483,8 @@ var init_historyPrepare = __esm({
         };
       }
       const [binanceFactory, coinbaseFactory] = await Promise.all([
-        (0, import_connectors4.getConnectorCreatorByName)(import_connectors3.ConnectorNames.Binance, projectRoot15),
-        (0, import_connectors4.getConnectorCreatorByName)(import_connectors3.ConnectorNames.Coinbase, projectRoot15)
+        (0, import_connectors4.getConnectorCreatorByName)(import_connectors3.ConnectorNames.Binance, projectRoot17),
+        (0, import_connectors4.getConnectorCreatorByName)(import_connectors3.ConnectorNames.Coinbase, projectRoot17)
       ]);
       const binance = binanceFactory ? await binanceFactory({ userName: userName3 }) : marketConnector;
       if (!binanceFactory) {
@@ -12742,9 +12742,9 @@ var init_runEnvironment = __esm({
     };
     resolveRunConnectorName = async ({
       value,
-      projectRoot: projectRoot15
+      projectRoot: projectRoot17
     }) => {
-      const connectorName = await (0, import_connectors5.resolveConnectorName)(value, projectRoot15);
+      const connectorName = await (0, import_connectors5.resolveConnectorName)(value, projectRoot17);
       if (connectorName) {
         return connectorName;
       }
@@ -12769,12 +12769,12 @@ var init_runEnvironment = __esm({
     };
     loadDeploymentReplayStrategies = async ({
       userName: userName3,
-      projectRoot: projectRoot15,
+      projectRoot: projectRoot17,
       deploymentId
     }) => {
       const [deployment, runtimeStrategies] = await Promise.all([
-        (0, import_runtimeStrategies.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot15, deploymentId }),
-        (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot15, deploymentId })
+        (0, import_runtimeStrategies.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot17, deploymentId }),
+        (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot17, deploymentId })
       ]);
       if (!deployment) {
         throw new Error(`Runtime deployment not found: ${deploymentId}`);
@@ -12823,7 +12823,7 @@ var init_runEnvironment = __esm({
       endTime,
       cacheOnly,
       interval: interval4,
-      projectRoot: projectRoot15,
+      projectRoot: projectRoot17,
       universe = "crypto",
       accountId,
       deploymentId,
@@ -12833,11 +12833,11 @@ var init_runEnvironment = __esm({
     }) => {
       const connectorName = await resolveRunConnectorName({
         value: connector,
-        projectRoot: projectRoot15
+        projectRoot: projectRoot17
       });
       const connectorFactory = await (0, import_connectors5.getConnectorCreatorByName)(
         connectorName,
-        projectRoot15
+        projectRoot17
       );
       if (!connectorFactory) {
         throw new Error(`Connector "${connectorName}" is not registered`);
@@ -12904,7 +12904,7 @@ var init_runEnvironment = __esm({
           connectorName,
           marketConnector,
           userName: userName3,
-          projectRoot: projectRoot15,
+          projectRoot: projectRoot17,
           shouldUseDedicatedReferences: universe === "crypto",
           requireDedicatedReferences: universe === "crypto",
           warn: (message) => console.log(import_chalk12.default.yellow(message))
@@ -14578,10 +14578,10 @@ var init_binanceBreadthUniversesUpdate = __esm({
     flags6 = import_args6.default.parse(process.argv);
     BINANCE_BREADTH_UNIVERSES_RELATIVE_PATH = "packages/node/src/config/binanceBreadthUniverses.json";
     main6 = async () => {
-      const projectRoot15 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+      const projectRoot17 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
       const connectorCreator = await (0, import_connectors7.getConnectorCreatorByName)(
         import_connectors6.ConnectorNames.Binance,
-        projectRoot15
+        projectRoot17
       );
       if (!connectorCreator) {
         throw new Error("Binance connector is not registered");
@@ -14614,7 +14614,7 @@ var init_binanceBreadthUniversesUpdate = __esm({
         return snapshot;
       }
       const outputPath = import_node_path5.default.join(
-        projectRoot15,
+        projectRoot17,
         BINANCE_BREADTH_UNIVERSES_RELATIVE_PATH
       );
       await import_promises9.default.writeFile(outputPath, serialized, "utf8");
@@ -15448,14 +15448,14 @@ var init_cleanTests = __esm({
     cleanUserTests = async (userName3) => {
       const testsPrefix = `users:${userName3}:tests:`;
       const testsCachePrefix = `users:${userName3}:cache:tests:`;
-      const projectRoot15 = process.env.PROJECT_CWD || process.cwd();
+      const projectRoot17 = process.env.PROJECT_CWD || process.cwd();
       const persistedArtifactsDir = import_path7.default.relative(
-        projectRoot15,
-        (0, import_backtestArtifacts2.getPersistedBacktestArtifactsDirForUser)(userName3, projectRoot15)
+        projectRoot17,
+        (0, import_backtestArtifacts2.getPersistedBacktestArtifactsDirForUser)(userName3, projectRoot17)
       );
       const cacheArtifactsDir = import_path7.default.relative(
-        projectRoot15,
-        (0, import_backtestArtifacts2.getBacktestCacheArtifactsDirForUser)(userName3, projectRoot15)
+        projectRoot17,
+        (0, import_backtestArtifacts2.getBacktestCacheArtifactsDirForUser)(userName3, projectRoot17)
       );
       if (flags11.cache) {
         console.log(import_chalk19.default.yellow(`clean user cache: ${userName3}`));
@@ -15468,11 +15468,11 @@ var init_cleanTests = __esm({
       await (0, import_cli7.cleanRedis)(testsCachePrefix);
       await (0, import_cli7.cleanFiles)(persistedArtifactsDir);
       await (0, import_cli7.cleanFiles)(cacheArtifactsDir);
-      await import_promises10.default.rm(import_path7.default.join(projectRoot15, persistedArtifactsDir), {
+      await import_promises10.default.rm(import_path7.default.join(projectRoot17, persistedArtifactsDir), {
         recursive: true,
         force: true
       });
-      await import_promises10.default.rm(import_path7.default.join(projectRoot15, cacheArtifactsDir), {
+      await import_promises10.default.rm(import_path7.default.join(projectRoot17, cacheArtifactsDir), {
         recursive: true,
         force: true
       });
@@ -17309,8 +17309,8 @@ volumes:
         `${DEV_COMPOSE_FILE} not found in project root. Run "npx @tradejs/cli infra-init" first.`
       );
     };
-    runDockerCompose = (composePath, args35) => {
-      const result = (0, import_node_child_process3.spawnSync)("docker", ["compose", "-f", composePath, ...args35], {
+    runDockerCompose = (composePath, args37) => {
+      const result = (0, import_node_child_process3.spawnSync)("docker", ["compose", "-f", composePath, ...args37], {
         stdio: "inherit"
       });
       if (result.error) {
@@ -23584,11 +23584,11 @@ var init_coreResearch = __esm({
       if (!Number.isFinite(numeric)) throw new Error(`${name} is invalid: ${text}`);
       return numeric;
     };
-    readSymbols = async (argv2, projectRoot15) => {
+    readSymbols = async (argv2, projectRoot17) => {
       const symbolsFile = valueAfter(argv2, "--symbolsFile");
       if (symbolsFile) {
         const parsed = JSON.parse(
-          await import_promises20.default.readFile(import_node_path14.default.resolve(projectRoot15, symbolsFile), "utf8")
+          await import_promises20.default.readFile(import_node_path14.default.resolve(projectRoot17, symbolsFile), "utf8")
         );
         if (!Array.isArray(parsed) || parsed.some((symbol) => typeof symbol !== "string")) {
           throw new Error("--symbolsFile must contain a JSON string array");
@@ -24654,12 +24654,15 @@ var init_support = __esm({
     buildReplayStrategyConfig = ({
       strategyConfig,
       interval: interval4
-    }) => buildRuntimeModeStrategyConfig({
-      strategyConfig,
-      env: "PARITY",
-      interval: interval4,
-      makeOrders: true,
-      recordRuntimeTrades: false
+    }) => ({
+      ...buildRuntimeModeStrategyConfig({
+        strategyConfig,
+        env: "PARITY",
+        interval: interval4,
+        makeOrders: false,
+        recordRuntimeTrades: false
+      }),
+      SIMULATE_ORDERS: true
     });
     toRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
     compactReplayAdditionalIndicators = (additionalIndicators) => {
@@ -24765,13 +24768,13 @@ var init_replayRuntimeEvidence = __esm({
       const parsed = Date.parse(raw);
       return Number.isFinite(parsed) ? parsed : null;
     };
-    resolveWindow = (flags32) => {
-      const endTime = toEpochMs2(flags32.endTime) ?? Date.now();
+    resolveWindow = (flags34) => {
+      const endTime = toEpochMs2(flags34.endTime) ?? Date.now();
       const hours = Math.max(
         1,
-        Number.parseInt(String(flags32.hours ?? 24), 10) || 24
+        Number.parseInt(String(flags34.hours ?? 24), 10) || 24
       );
-      const startTime = toEpochMs2(flags32.startTime) ?? endTime - hours * 60 * 60 * 1e3;
+      const startTime = toEpochMs2(flags34.startTime) ?? endTime - hours * 60 * 60 * 1e3;
       if (startTime >= endTime) {
         throw new Error(
           `Invalid window: startTime (${startTime}) must be less than endTime (${endTime})`
@@ -24780,7 +24783,7 @@ var init_replayRuntimeEvidence = __esm({
       return {
         startTime,
         endTime,
-        source: flags32.startTime != null || flags32.endTime != null ? "explicit" : "hours"
+        source: flags34.startTime != null || flags34.endTime != null ? "explicit" : "hours"
       };
     };
     parseStrategyFilter = (value) => String(value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
@@ -24970,9 +24973,9 @@ var init_replayRuntimeEvidence = __esm({
       strategies,
       userName: userName3,
       runtimeEvidenceFile,
-      projectRoot: projectRoot15
+      projectRoot: projectRoot17
     }) => {
-      const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path15.default.resolve(projectRoot15, runtimeEvidenceFile.trim()) : null;
+      const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path15.default.resolve(projectRoot17, runtimeEvidenceFile.trim()) : null;
       if (runtimeEvidencePath) {
         const artifact = JSON.parse(
           await import_promises21.default.readFile(runtimeEvidencePath, "utf8")
@@ -25006,23 +25009,23 @@ var init_replayRuntimeEvidence = __esm({
       };
     };
     replayRuntimeEvidence = async () => {
-      const flags32 = import_args25.default.parse(process.argv);
-      const projectRoot15 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
-      const userName3 = String(flags32.user ?? "root");
-      const { startTime, endTime, source } = resolveWindow(flags32);
+      const flags34 = import_args25.default.parse(process.argv);
+      const projectRoot17 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+      const userName3 = String(flags34.user ?? "root");
+      const { startTime, endTime, source } = resolveWindow(flags34);
       const replay = await loadReplayResult({
         userName: userName3,
-        replayKey: typeof flags32.replayKey === "string" && flags32.replayKey.trim() ? flags32.replayKey.trim() : void 0
+        replayKey: typeof flags34.replayKey === "string" && flags34.replayKey.trim() ? flags34.replayKey.trim() : void 0
       });
-      const explicitStrategies = parseStrategyFilter(flags32.strategy);
+      const explicitStrategies = parseStrategyFilter(flags34.strategy);
       const strategies = explicitStrategies.length ? explicitStrategies : getReplayStrategies(replay.value);
       const runtime = await loadRuntimePayload({
         startTime,
         endTime,
         strategies,
         userName: userName3,
-        runtimeEvidenceFile: flags32.runtimeEvidence,
-        projectRoot: projectRoot15
+        runtimeEvidenceFile: flags34.runtimeEvidence,
+        projectRoot: projectRoot17
       });
       const replayValue = asRecord4(replay.value);
       const artifact = {
@@ -25047,6 +25050,10 @@ var init_replayRuntimeEvidence = __esm({
           availableKeys: replay.availableKeys,
           startedAt: replayValue.startedAt ?? null,
           finishedAt: replayValue.finishedAt ?? null,
+          durationSeconds: replayValue.durationSeconds ?? null,
+          cycleCount: replayValue.cycleCount ?? null,
+          abortedCycles: replayValue.abortedCycles ?? null,
+          signalsCount: replayValue.signalsCount ?? null,
           resultsByStrategies: asArray2(replayValue.resultsByStrategies).filter(
             (row) => !strategies.length || strategies.includes(String(row.strategyName ?? ""))
           ),
@@ -25057,7 +25064,7 @@ var init_replayRuntimeEvidence = __esm({
         },
         runtime: runtime.payload
       };
-      const outPath = import_node_path15.default.resolve(projectRoot15, String(flags32.out));
+      const outPath = import_node_path15.default.resolve(projectRoot17, String(flags34.out));
       await import_promises21.default.mkdir(import_node_path15.default.dirname(outPath), { recursive: true });
       await import_promises21.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
@@ -25317,12 +25324,12 @@ var init_runtimeEvidenceDeployment = __esm({
     });
     resolveRuntimeEvidenceDeploymentSnapshot = async ({
       userName: userName3,
-      projectRoot: projectRoot15,
+      projectRoot: projectRoot17,
       deploymentId
     }) => {
       const [deployment, strategies] = await Promise.all([
-        (0, import_runtimeStrategies3.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot15, deploymentId }),
-        (0, import_runtimeStrategies3.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot15, deploymentId })
+        (0, import_runtimeStrategies3.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot17, deploymentId }),
+        (0, import_runtimeStrategies3.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot17, deploymentId })
       ]);
       if (!deployment) {
         throw new Error(`Runtime deployment not found: ${deploymentId}`);
@@ -25606,12 +25613,981 @@ var init_runtimeEvidenceArtifacts = __esm({
   }
 });
 
+// src/lib/runtimeEvidenceProducer.ts
+var import_node_crypto11, import_promises23, import_node_path17, isRecord2, sha2562, parseRuntimeEvidenceProducer, resolveRuntimeEvidenceProducer;
+var init_runtimeEvidenceProducer = __esm({
+  "src/lib/runtimeEvidenceProducer.ts"() {
+    "use strict";
+    import_node_crypto11 = require("crypto");
+    import_promises23 = __toESM(require("fs/promises"));
+    import_node_path17 = __toESM(require("path"));
+    isRecord2 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+    sha2562 = (value) => (0, import_node_crypto11.createHash)("sha256").update(value).digest("hex");
+    parseRuntimeEvidenceProducer = (value) => {
+      const producer = isRecord2(value) ? value : null;
+      const runtimePackageManifest = isRecord2(producer?.runtimePackageManifest) ? producer.runtimePackageManifest : null;
+      if (producer?.schemaVersion !== 1 || typeof producer.projectSha !== "string" || !/^[a-f0-9]{40}$/.test(producer.projectSha) || typeof producer.imageDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(producer.imageDigest) || runtimePackageManifest?.file !== "runtime-package-manifest.json" || typeof runtimePackageManifest.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(runtimePackageManifest.sha256)) {
+        throw new Error("Runtime evidence producer image identity is invalid");
+      }
+      return producer;
+    };
+    resolveRuntimeEvidenceProducer = async ({
+      projectRoot: projectRoot17,
+      required: required4
+    }) => {
+      const projectSha = String(process.env.TRADEJS_PROJECT_SHA ?? "").trim();
+      const imageDigest = String(
+        process.env.TRADEJS_PROJECT_IMAGE_DIGEST ?? ""
+      ).trim();
+      if (!projectSha && !imageDigest && !required4) {
+        return null;
+      }
+      if (!/^[a-f0-9]{40}$/.test(projectSha)) {
+        throw new Error(
+          "TRADEJS_PROJECT_SHA must be a full lowercase Git SHA before publishing runtime evidence"
+        );
+      }
+      if (!/^sha256:[a-f0-9]{64}$/.test(imageDigest)) {
+        throw new Error(
+          "TRADEJS_PROJECT_IMAGE_DIGEST must be an immutable sha256 digest before publishing runtime evidence"
+        );
+      }
+      const manifestPath = import_node_path17.default.join(projectRoot17, "runtime-package-manifest.json");
+      let manifest;
+      try {
+        manifest = await import_promises23.default.readFile(manifestPath);
+      } catch (error) {
+        if (!required4 && error.code === "ENOENT") {
+          return null;
+        }
+        throw new Error(
+          `Runtime package manifest is required for runtime evidence: ${manifestPath}`,
+          { cause: error }
+        );
+      }
+      return {
+        schemaVersion: 1,
+        projectSha,
+        imageDigest,
+        runtimePackageManifest: {
+          file: "runtime-package-manifest.json",
+          sha256: sha2562(manifest)
+        }
+      };
+    };
+  }
+});
+
+// src/lib/runtimeFeedbackArtifacts.ts
+var import_node_crypto12, import_promises24, import_node_path18, RUNTIME_FEEDBACK_MANIFEST_FILE, RUNTIME_FEEDBACK_REPLAY_FILE, RUNTIME_FEEDBACK_LOG_FILE, RUNTIME_FEEDBACK_COMPLETE_FILE, isRecord3, sha2563, safeSegment2, parsePayload, parseManifest2, assertReplayMatchesRuntimeEvidence, sealRuntimeFeedbackReplayBundle, verifyRuntimeFeedbackReplayBundle, discoverRuntimeFeedbackReplayBundles, verifyRuntimeFeedbackReplaySource;
+var init_runtimeFeedbackArtifacts = __esm({
+  "src/lib/runtimeFeedbackArtifacts.ts"() {
+    "use strict";
+    import_node_crypto12 = require("crypto");
+    import_promises24 = __toESM(require("fs/promises"));
+    import_node_path18 = __toESM(require("path"));
+    init_runtimeEvidenceDeployment();
+    init_runtimeEvidenceArtifacts();
+    init_runtimeEvidenceProducer();
+    RUNTIME_FEEDBACK_MANIFEST_FILE = "manifest.json";
+    RUNTIME_FEEDBACK_REPLAY_FILE = "replay-runtime-evidence.json";
+    RUNTIME_FEEDBACK_LOG_FILE = "replay.log";
+    RUNTIME_FEEDBACK_COMPLETE_FILE = ".complete";
+    isRecord3 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+    sha2563 = (value) => (0, import_node_crypto12.createHash)("sha256").update(value).digest("hex");
+    safeSegment2 = (value, fallback) => {
+      const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+      return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
+    };
+    parsePayload = (value, expectedFile) => {
+      const payload = isRecord3(value) ? value : null;
+      if (payload?.file !== expectedFile || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number" || !Number.isFinite(payload.bytes) || payload.bytes < 0) {
+        throw new Error(`Invalid runtime feedback payload: ${expectedFile}`);
+      }
+      return payload;
+    };
+    parseManifest2 = (value) => {
+      const manifest = isRecord3(value) ? value : null;
+      const window = isRecord3(manifest?.window) ? manifest.window : null;
+      const runtimeEvidence2 = isRecord3(manifest?.runtimeEvidence) ? manifest.runtimeEvidence : null;
+      const safety = isRecord3(manifest?.safety) ? manifest.safety : null;
+      const payloads = isRecord3(manifest?.payloads) ? manifest.payloads : null;
+      if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-feedback-replay" || typeof manifest.artifactId !== "string" || !manifest.artifactId.trim() || typeof manifest.runId !== "string" || !manifest.runId.trim() || typeof manifest.deploymentId !== "string" || !manifest.deploymentId.trim() || typeof manifest.deploymentCompositionId !== "string" || !/^dc1:[a-f0-9]{16}$/.test(manifest.deploymentCompositionId) || typeof manifest.userName !== "string" || !manifest.userName.trim() || typeof manifest.createdAt !== "number" || typeof window?.startTime !== "number" || typeof window.endTime !== "number" || typeof runtimeEvidence2?.artifactId !== "string" || typeof runtimeEvidence2.payloadSha256 !== "string" || !/^[a-f0-9]{64}$/.test(runtimeEvidence2.payloadSha256) || !Array.isArray(manifest.activeStrategies) || manifest.activeStrategies.length === 0 || !manifest.activeStrategies.every(
+        (strategy) => typeof strategy === "string" && strategy.trim()
+      ) || typeof manifest.cycleCount !== "number" || !Number.isFinite(manifest.cycleCount) || manifest.cycleCount <= 0 || safety?.cacheOnly !== true || safety.externalOrderPlacement !== false || safety.redis !== "isolated" || safety.timescale !== "read_only") {
+        throw new Error("Invalid runtime feedback replay manifest");
+      }
+      const replayEvidence = parsePayload(
+        payloads?.replayEvidence,
+        RUNTIME_FEEDBACK_REPLAY_FILE
+      );
+      const log = parsePayload(payloads?.log, RUNTIME_FEEDBACK_LOG_FILE);
+      return {
+        ...manifest,
+        producer: parseRuntimeEvidenceProducer(manifest.producer),
+        payloads: {
+          replayEvidence: {
+            ...replayEvidence,
+            file: RUNTIME_FEEDBACK_REPLAY_FILE
+          },
+          log: { ...log, file: RUNTIME_FEEDBACK_LOG_FILE }
+        }
+      };
+    };
+    assertReplayMatchesRuntimeEvidence = ({
+      replayEvidence,
+      runtimeEvidence: runtimeEvidence2
+    }) => {
+      if (replayEvidence.reportType !== "replay-runtime-evidence") {
+        throw new Error("Runtime feedback replay payload has the wrong reportType");
+      }
+      const replayWindow = isRecord3(replayEvidence.window) ? replayEvidence.window : null;
+      if (replayWindow?.startTime !== runtimeEvidence2.manifest.window.startTime || replayWindow.endTime !== runtimeEvidence2.manifest.window.endTime) {
+        throw new Error("Runtime feedback replay window does not match evidence");
+      }
+      const runtimeDeployment = parseRuntimeEvidenceDeploymentSnapshot(
+        runtimeEvidence2.artifact.deployment
+      );
+      const replayDeployment = parseRuntimeEvidenceDeploymentSnapshot(
+        replayEvidence.deployment
+      );
+      if (replayDeployment.id !== runtimeDeployment.id || replayDeployment.deploymentCompositionId !== runtimeDeployment.deploymentCompositionId) {
+        throw new Error(
+          "Runtime feedback replay deployment does not match evidence"
+        );
+      }
+    };
+    sealRuntimeFeedbackReplayBundle = async ({
+      bundleDir,
+      runId,
+      runtimeEvidenceBundle
+    }) => {
+      const replayEvidencePath = import_node_path18.default.join(bundleDir, RUNTIME_FEEDBACK_REPLAY_FILE);
+      const logPath = import_node_path18.default.join(bundleDir, RUNTIME_FEEDBACK_LOG_FILE);
+      const [replayPayload, logPayload] = await Promise.all([
+        import_promises24.default.readFile(replayEvidencePath),
+        import_promises24.default.readFile(logPath)
+      ]);
+      const replayEvidence = JSON.parse(replayPayload.toString("utf8"));
+      assertReplayMatchesRuntimeEvidence({
+        replayEvidence,
+        runtimeEvidence: runtimeEvidenceBundle
+      });
+      const replay = isRecord3(replayEvidence.replay) ? replayEvidence.replay : null;
+      const cycleCount = Number(replay?.cycleCount);
+      if (!Number.isFinite(cycleCount) || cycleCount <= 0) {
+        throw new Error(
+          `Runtime feedback replay produced no comparable cycles: ${String(replay?.cycleCount ?? "missing")}`
+        );
+      }
+      const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+        runtimeEvidenceBundle.artifact.deployment
+      );
+      const producer = parseRuntimeEvidenceProducer(
+        runtimeEvidenceBundle.artifact.producer
+      );
+      const safeRunId = safeSegment2(runId, "run");
+      const artifactId = `${runtimeEvidenceBundle.manifest.artifactId}_${safeRunId}`;
+      const manifest = {
+        schemaVersion: 1,
+        reportType: "runtime-feedback-replay",
+        artifactId,
+        runId: safeRunId,
+        deploymentId: deployment.id,
+        deploymentCompositionId: deployment.deploymentCompositionId,
+        userName: runtimeEvidenceBundle.manifest.userName,
+        createdAt: Date.now(),
+        window: { ...runtimeEvidenceBundle.manifest.window },
+        runtimeEvidence: {
+          artifactId: runtimeEvidenceBundle.manifest.artifactId,
+          payloadSha256: runtimeEvidenceBundle.manifest.payload.sha256
+        },
+        producer,
+        activeStrategies: activeRuntimeEvidenceStrategies(deployment).map(
+          ({ strategyName }) => strategyName
+        ),
+        cycleCount,
+        safety: {
+          cacheOnly: true,
+          externalOrderPlacement: false,
+          redis: "isolated",
+          timescale: "read_only"
+        },
+        payloads: {
+          replayEvidence: {
+            file: RUNTIME_FEEDBACK_REPLAY_FILE,
+            sha256: sha2563(replayPayload),
+            bytes: replayPayload.byteLength
+          },
+          log: {
+            file: RUNTIME_FEEDBACK_LOG_FILE,
+            sha256: sha2563(logPayload),
+            bytes: logPayload.byteLength
+          }
+        }
+      };
+      await import_promises24.default.writeFile(
+        import_node_path18.default.join(bundleDir, RUNTIME_FEEDBACK_MANIFEST_FILE),
+        `${JSON.stringify(manifest, null, 2)}
+`,
+        "utf8"
+      );
+      await import_promises24.default.writeFile(
+        import_node_path18.default.join(bundleDir, RUNTIME_FEEDBACK_COMPLETE_FILE),
+        `${artifactId}
+`,
+        "utf8"
+      );
+      return verifyRuntimeFeedbackReplayBundle(bundleDir);
+    };
+    verifyRuntimeFeedbackReplayBundle = async (bundleDir) => {
+      const manifestPath = import_node_path18.default.join(bundleDir, RUNTIME_FEEDBACK_MANIFEST_FILE);
+      const replayEvidencePath = import_node_path18.default.join(bundleDir, RUNTIME_FEEDBACK_REPLAY_FILE);
+      const logPath = import_node_path18.default.join(bundleDir, RUNTIME_FEEDBACK_LOG_FILE);
+      const completePath = import_node_path18.default.join(bundleDir, RUNTIME_FEEDBACK_COMPLETE_FILE);
+      const [manifestText, replayPayload, logPayload, completeText] = await Promise.all([
+        import_promises24.default.readFile(manifestPath, "utf8"),
+        import_promises24.default.readFile(replayEvidencePath),
+        import_promises24.default.readFile(logPath),
+        import_promises24.default.readFile(completePath, "utf8")
+      ]);
+      const manifest = parseManifest2(JSON.parse(manifestText));
+      if (completeText.trim() !== manifest.artifactId) {
+        throw new Error(`Invalid runtime feedback completion marker: ${bundleDir}`);
+      }
+      for (const [payload, descriptor] of [
+        [replayPayload, manifest.payloads.replayEvidence],
+        [logPayload, manifest.payloads.log]
+      ]) {
+        if (payload.byteLength !== descriptor.bytes) {
+          throw new Error(
+            `Runtime feedback payload size mismatch: ${descriptor.file}`
+          );
+        }
+        if (sha2563(payload) !== descriptor.sha256) {
+          throw new Error(
+            `Runtime feedback payload checksum mismatch: ${descriptor.file}`
+          );
+        }
+      }
+      const replayEvidence = JSON.parse(replayPayload.toString("utf8"));
+      if (replayEvidence.reportType !== "replay-runtime-evidence") {
+        throw new Error("Invalid runtime feedback replay evidence payload");
+      }
+      const replayWindow = isRecord3(replayEvidence.window) ? replayEvidence.window : null;
+      const replay = isRecord3(replayEvidence.replay) ? replayEvidence.replay : null;
+      const replayDeployment = parseRuntimeEvidenceDeploymentSnapshot(
+        replayEvidence.deployment
+      );
+      const replayStrategies = activeRuntimeEvidenceStrategies(replayDeployment).map(({ strategyName }) => strategyName).sort();
+      if (replayEvidence.userName !== manifest.userName || replayWindow?.startTime !== manifest.window.startTime || replayWindow.endTime !== manifest.window.endTime || replayDeployment.id !== manifest.deploymentId || replayDeployment.deploymentCompositionId !== manifest.deploymentCompositionId || Number(replay?.cycleCount) !== manifest.cycleCount || JSON.stringify(replayStrategies) !== JSON.stringify([...manifest.activeStrategies].sort())) {
+        throw new Error("Runtime feedback replay payload does not match manifest");
+      }
+      return {
+        bundleDir,
+        manifestPath,
+        replayEvidencePath,
+        logPath,
+        manifest,
+        replayEvidence
+      };
+    };
+    discoverRuntimeFeedbackReplayBundles = async (rootDir) => {
+      const bundles = [];
+      const visit = async (directory, depth) => {
+        if (depth > 10) return;
+        let entries;
+        try {
+          entries = await import_promises24.default.readdir(directory, { withFileTypes: true });
+        } catch (error) {
+          if (error.code === "ENOENT") return;
+          throw error;
+        }
+        const names = new Set(entries.map((entry) => entry.name));
+        if (names.has(RUNTIME_FEEDBACK_MANIFEST_FILE) && names.has(RUNTIME_FEEDBACK_REPLAY_FILE) && names.has(RUNTIME_FEEDBACK_LOG_FILE) && names.has(RUNTIME_FEEDBACK_COMPLETE_FILE)) {
+          bundles.push(directory);
+          return;
+        }
+        await Promise.all(
+          entries.filter(
+            (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
+          ).map((entry) => visit(import_node_path18.default.join(directory, entry.name), depth + 1))
+        );
+      };
+      await visit(rootDir, 0);
+      return bundles.sort();
+    };
+    verifyRuntimeFeedbackReplaySource = async ({
+      bundleDir,
+      runtimeEvidenceBundleDir
+    }) => {
+      const [feedback, runtimeEvidence2] = await Promise.all([
+        verifyRuntimeFeedbackReplayBundle(bundleDir),
+        verifyRuntimeEvidenceBundle(runtimeEvidenceBundleDir)
+      ]);
+      if (feedback.manifest.runtimeEvidence.artifactId !== runtimeEvidence2.manifest.artifactId || feedback.manifest.runtimeEvidence.payloadSha256 !== runtimeEvidence2.manifest.payload.sha256) {
+        throw new Error("Runtime feedback bundle references different evidence");
+      }
+      assertReplayMatchesRuntimeEvidence({
+        replayEvidence: feedback.replayEvidence,
+        runtimeEvidence: runtimeEvidence2
+      });
+      return { feedback, runtimeEvidence: runtimeEvidence2 };
+    };
+  }
+});
+
+// src/lib/runtimeFeedbackReplay.ts
+var import_node_child_process6, import_promises25, import_node_path19, REQUIRED_ENV, FORBIDDEN_SECRET_ENV, unsafeRedisHosts, safeSegment3, assertRuntimeFeedbackReplaySafety, buildRuntimeFeedbackReplayCommands, runLoggedCommand, runRuntimeFeedbackReplay;
+var init_runtimeFeedbackReplay = __esm({
+  "src/lib/runtimeFeedbackReplay.ts"() {
+    "use strict";
+    import_node_child_process6 = require("child_process");
+    import_promises25 = __toESM(require("fs/promises"));
+    import_node_path19 = __toESM(require("path"));
+    init_runtimeEvidenceDeployment();
+    init_runtimeEvidenceArtifacts();
+    init_runtimeEvidenceProducer();
+    init_runtimeFeedbackArtifacts();
+    REQUIRED_ENV = {
+      RUNTIME_FEEDBACK_ISOLATED_REDIS: "true",
+      MAKE_ORDERS: "false",
+      TRADEJS_EXTERNAL_ORDER_PLACEMENT: "false"
+    };
+    FORBIDDEN_SECRET_ENV = [
+      "AGENT_GITHUB_TOKEN",
+      "AI_API_KEY",
+      "ANTHROPIC_API_KEY",
+      "AUTH_SECRET",
+      "BYBIT_API_KEY",
+      "BYBIT_API_SECRET",
+      "COINALYZE_API_KEY",
+      "COINMARKETCAP_API_KEY",
+      "GITHUB_TOKEN",
+      "GIT_SSH_PRIVATE_KEY",
+      "NEXTAUTH_SECRET",
+      "NPM_TOKEN",
+      "OPENAI_API_KEY",
+      "OPENROUTER_API_KEY",
+      "SSH_PRIVATE_KEY",
+      "TG_BOT_TOKEN"
+    ];
+    unsafeRedisHosts = /* @__PURE__ */ new Set([
+      "127.0.0.1",
+      "::1",
+      "inv-redis",
+      "localhost",
+      "redis"
+    ]);
+    safeSegment3 = (value, fallback) => {
+      const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+      return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
+    };
+    assertRuntimeFeedbackReplaySafety = (env) => {
+      for (const [name, expected] of Object.entries(REQUIRED_ENV)) {
+        if (env[name] !== expected) {
+          throw new Error(`Runtime feedback replay requires ${name}=${expected}`);
+        }
+      }
+      const redisHost = String(env.REDIS_HOST ?? "").trim().toLowerCase();
+      if (!redisHost || unsafeRedisHosts.has(redisHost)) {
+        throw new Error(
+          `Runtime feedback replay requires a named isolated Redis host, received ${redisHost || "[missing]"}`
+        );
+      }
+      const pgOptions = String(env.PGOPTIONS ?? "");
+      if (!/default_transaction_read_only\s*=\s*on/i.test(pgOptions)) {
+        throw new Error(
+          "Runtime feedback replay requires PGOPTIONS with default_transaction_read_only=on"
+        );
+      }
+      if (env.TRADEJS_TIMESCALE_READ_ONLY !== "true") {
+        throw new Error(
+          "Runtime feedback replay requires TRADEJS_TIMESCALE_READ_ONLY=true"
+        );
+      }
+      const exposedSecrets = FORBIDDEN_SECRET_ENV.filter(
+        (name) => String(env[name] ?? "").trim()
+      );
+      if (exposedSecrets.length) {
+        throw new Error(
+          `Runtime feedback replay received forbidden credentials: ${exposedSecrets.join(", ")}`
+        );
+      }
+    };
+    buildRuntimeFeedbackReplayCommands = ({
+      cliPath,
+      runtimeEvidencePath,
+      replayEvidencePath,
+      userName: userName3,
+      connectorName,
+      deploymentId,
+      interval: interval4,
+      startTime,
+      endTime
+    }) => [
+      [
+        cliPath,
+        "replay",
+        "--user",
+        userName3,
+        "--connector",
+        connectorName,
+        "--deployment",
+        deploymentId,
+        "--timeframe",
+        interval4,
+        "--startTime",
+        String(startTime),
+        "--endTime",
+        String(endTime),
+        "--runtimeEvidence",
+        runtimeEvidencePath,
+        "--cacheOnly"
+      ],
+      [
+        cliPath,
+        "replay-runtime-evidence",
+        "--user",
+        userName3,
+        "--runtimeEvidence",
+        runtimeEvidencePath,
+        "--startTime",
+        String(startTime),
+        "--endTime",
+        String(endTime),
+        "--out",
+        replayEvidencePath
+      ]
+    ];
+    runLoggedCommand = async ({
+      executable,
+      command,
+      cwd,
+      env,
+      logHandle
+    }) => {
+      await logHandle.write(`
+$ ${[executable, ...command].join(" ")}
+`);
+      await new Promise((resolve, reject) => {
+        let pendingLogWrite = Promise.resolve();
+        const appendLog = (chunk) => {
+          pendingLogWrite = pendingLogWrite.then(async () => {
+            await logHandle.write(chunk);
+          });
+        };
+        const child = (0, import_node_child_process6.spawn)(executable, command, {
+          cwd,
+          env,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        child.stdout.on("data", (chunk) => {
+          process.stdout.write(chunk);
+          appendLog(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+          process.stderr.write(chunk);
+          appendLog(chunk);
+        });
+        child.once("error", reject);
+        child.once("close", (code, signal) => {
+          void pendingLogWrite.then(() => {
+            if (code === 0) {
+              resolve();
+              return;
+            }
+            reject(
+              new Error(
+                `Runtime feedback command failed: exit=${String(code)} signal=${String(signal)}`
+              )
+            );
+          }, reject);
+        });
+      });
+    };
+    runRuntimeFeedbackReplay = async ({
+      runtimeEvidencePath,
+      outDir,
+      runId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${process.pid}`,
+      projectRoot: projectRoot17,
+      env = process.env,
+      executable = process.execPath,
+      cliPath = process.argv[1]
+    }) => {
+      assertRuntimeFeedbackReplaySafety(env);
+      if (!cliPath) {
+        throw new Error("Cannot resolve the TradeJS CLI executable path");
+      }
+      const runtimeEvidenceBundle = await verifyRuntimeEvidenceBundle(
+        import_node_path19.default.dirname(runtimeEvidencePath)
+      );
+      if (import_node_path19.default.resolve(runtimeEvidenceBundle.payloadPath) !== runtimeEvidencePath) {
+        throw new Error(
+          `Runtime evidence must be the verified bundle payload: ${runtimeEvidenceBundle.payloadPath}`
+        );
+      }
+      const deployedProducer = parseRuntimeEvidenceProducer(
+        runtimeEvidenceBundle.artifact.producer
+      );
+      const currentProducer = await resolveRuntimeEvidenceProducer({
+        projectRoot: projectRoot17,
+        required: true
+      });
+      if (!currentProducer || currentProducer.projectSha !== deployedProducer.projectSha || currentProducer.imageDigest !== deployedProducer.imageDigest || currentProducer.runtimePackageManifest.sha256 !== deployedProducer.runtimePackageManifest.sha256) {
+        throw new Error(
+          "Runtime feedback replay image identity does not match runtime evidence"
+        );
+      }
+      const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+        runtimeEvidenceBundle.artifact.deployment
+      );
+      const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
+      const intervals = new Set(
+        activeStrategies.map(({ interval: interval4 }) => String(interval4))
+      );
+      if (intervals.size !== 1) {
+        throw new Error(
+          `Runtime feedback replay requires one interval, received ${[...intervals].join(",")}`
+        );
+      }
+      await import_promises25.default.mkdir(outDir, { recursive: true });
+      const existing = await import_promises25.default.readdir(outDir);
+      if (existing.length) {
+        throw new Error(
+          `Runtime feedback output directory must be empty: ${outDir}`
+        );
+      }
+      const replayEvidencePath = import_node_path19.default.join(outDir, RUNTIME_FEEDBACK_REPLAY_FILE);
+      const logHandle = await import_promises25.default.open(
+        import_node_path19.default.join(outDir, RUNTIME_FEEDBACK_LOG_FILE),
+        "wx"
+      );
+      const commands = buildRuntimeFeedbackReplayCommands({
+        cliPath,
+        runtimeEvidencePath,
+        replayEvidencePath,
+        userName: runtimeEvidenceBundle.manifest.userName,
+        connectorName: deployment.connectorName,
+        deploymentId: deployment.id,
+        interval: [...intervals][0],
+        startTime: runtimeEvidenceBundle.manifest.window.startTime,
+        endTime: runtimeEvidenceBundle.manifest.window.endTime
+      });
+      try {
+        for (const command of commands) {
+          await runLoggedCommand({
+            executable,
+            command,
+            cwd: projectRoot17,
+            env,
+            logHandle
+          });
+        }
+      } finally {
+        await logHandle.close();
+      }
+      return sealRuntimeFeedbackReplayBundle({
+        bundleDir: outDir,
+        runId: safeSegment3(runId, "run"),
+        runtimeEvidenceBundle
+      });
+    };
+  }
+});
+
+// src/scripts/runtimeFeedbackReplay.ts
+var runtimeFeedbackReplay_exports = {};
+__export(runtimeFeedbackReplay_exports, {
+  main: () => main34,
+  runtimeFeedbackReplay: () => runtimeFeedbackReplay
+});
+var import_node_path20, import_args26, import_chalk39, flags25, projectRoot9, runtimeFeedbackReplay, main34;
+var init_runtimeFeedbackReplay2 = __esm({
+  "src/scripts/runtimeFeedbackReplay.ts"() {
+    "use strict";
+    import_node_path20 = __toESM(require("path"));
+    import_args26 = __toESM(require("args"));
+    import_chalk39 = __toESM(require("chalk"));
+    init_runtimeFeedbackReplay();
+    import_args26.default.option("runtimeEvidence", "Verified runtime evidence JSON");
+    import_args26.default.option("outDir", "New writable directory for replay output");
+    import_args26.default.option("runId", "Stable identifier for this replay attempt");
+    flags25 = import_args26.default.parse(process.argv);
+    projectRoot9 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    runtimeFeedbackReplay = async () => {
+      const runtimeEvidence2 = String(flags25.runtimeEvidence ?? "").trim();
+      const outDir = String(flags25.outDir ?? "").trim();
+      if (!runtimeEvidence2 || !outDir) {
+        throw new Error(
+          "Provide --runtimeEvidence and --outDir for runtime feedback replay."
+        );
+      }
+      const verified = await runRuntimeFeedbackReplay({
+        runtimeEvidencePath: import_node_path20.default.resolve(projectRoot9, runtimeEvidence2),
+        outDir: import_node_path20.default.resolve(projectRoot9, outDir),
+        runId: String(flags25.runId ?? "").trim() || void 0,
+        projectRoot: projectRoot9
+      });
+      console.log(
+        import_chalk39.default.green(
+          `Runtime feedback replay sealed: ${verified.manifest.artifactId}`
+        )
+      );
+      console.log(
+        JSON.stringify(
+          {
+            bundleDir: verified.bundleDir,
+            manifestPath: verified.manifestPath,
+            replayEvidencePath: verified.replayEvidencePath
+          },
+          null,
+          2
+        )
+      );
+    };
+    main34 = runtimeFeedbackReplay;
+  }
+});
+
+// src/lib/runtimeEvidenceSync.ts
+var import_node_child_process7, import_promises26, import_node_path21, import_node_util, execFileAsync, isExistingDestinationError2, safeSegment4, withTrailingSlash, dateParts2, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
+var init_runtimeEvidenceSync = __esm({
+  "src/lib/runtimeEvidenceSync.ts"() {
+    "use strict";
+    import_node_child_process7 = require("child_process");
+    import_promises26 = __toESM(require("fs/promises"));
+    import_node_path21 = __toESM(require("path"));
+    import_node_util = require("util");
+    init_runtimeEvidenceArtifacts();
+    init_runtimeEvidenceDeployment();
+    execFileAsync = (0, import_node_util.promisify)(import_node_child_process7.execFile);
+    isExistingDestinationError2 = (error) => {
+      const code = error.code;
+      return code === "EEXIST" || code === "ENOTEMPTY";
+    };
+    safeSegment4 = (value, fallback) => {
+      const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+      return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
+    };
+    withTrailingSlash = (value) => value.endsWith("/") ? value : `${value}/`;
+    dateParts2 = (timestamp) => {
+      const date = new Date(timestamp);
+      return [
+        String(date.getUTCFullYear()),
+        String(date.getUTCMonth() + 1).padStart(2, "0"),
+        String(date.getUTCDate()).padStart(2, "0")
+      ];
+    };
+    buildRuntimeEvidenceRsyncArgs = ({
+      source,
+      destination
+    }) => [
+      "--recursive",
+      "--times",
+      "--partial",
+      "--partial-dir=.rsync-partial",
+      "--prune-empty-dirs",
+      withTrailingSlash(source),
+      withTrailingSlash(destination)
+    ];
+    receiptPath = (receiptsRoot, artifactId) => import_node_path21.default.join(receiptsRoot, `${safeSegment4(artifactId, "artifact")}.json`);
+    compareBundles = (left, right) => left.manifest.window.endTime - right.manifest.window.endTime || left.manifest.createdAt - right.manifest.createdAt;
+    listPendingRuntimeEvidenceBundles = async ({
+      evidenceRoot,
+      deploymentId
+    }) => {
+      const safeDeploymentId = safeSegment4(deploymentId, "production");
+      const artifactsRoot = import_node_path21.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const receiptsRoot = import_node_path21.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const bundles = await discoverRuntimeEvidenceBundles(artifactsRoot);
+      const pending = [];
+      for (const bundleDir of bundles) {
+        const verified = await verifyRuntimeEvidenceBundle(bundleDir);
+        if (verified.manifest.deploymentId !== safeDeploymentId) continue;
+        assertCurrentRuntimeEvidenceArtifact(verified.artifact);
+        try {
+          await import_promises26.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
+          continue;
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+        pending.push(verified);
+      }
+      return pending.sort(compareBundles);
+    };
+    markRuntimeEvidenceBundleProcessed = async ({
+      evidenceRoot,
+      deploymentId,
+      bundleDir,
+      scorecardPath,
+      runtimeFeedback
+    }) => {
+      const safeDeploymentId = safeSegment4(deploymentId, "production");
+      const verified = await verifyRuntimeEvidenceBundle(bundleDir);
+      if (verified.manifest.deploymentId !== safeDeploymentId) {
+        throw new Error(
+          `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
+        );
+      }
+      const receiptsRoot = import_node_path21.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const finalPath = receiptPath(receiptsRoot, verified.manifest.artifactId);
+      const temporaryPath = `${finalPath}.tmp-${process.pid}`;
+      const receipt = {
+        schemaVersion: runtimeFeedback ? 2 : 1,
+        artifactId: verified.manifest.artifactId,
+        payloadSha256: verified.manifest.payload.sha256,
+        processedAt: Date.now(),
+        scorecardPath: scorecardPath ?? null,
+        ...runtimeFeedback ? {
+          runtimeFeedbackArtifactId: runtimeFeedback.artifactId,
+          replayEvidenceSha256: runtimeFeedback.replayEvidenceSha256
+        } : {}
+      };
+      await import_promises26.default.mkdir(receiptsRoot, { recursive: true });
+      await import_promises26.default.writeFile(
+        temporaryPath,
+        `${JSON.stringify(receipt, null, 2)}
+`,
+        "utf8"
+      );
+      await import_promises26.default.rename(temporaryPath, finalPath);
+      return finalPath;
+    };
+    syncRuntimeEvidenceBundles = async ({
+      source,
+      evidenceRoot,
+      deploymentId,
+      runRsync = async (args37) => {
+        const result = await execFileAsync("rsync", args37, {
+          maxBuffer: 10 * 1024 * 1024
+        });
+        return { stdout: result.stdout, stderr: result.stderr };
+      }
+    }) => {
+      const safeDeploymentId = safeSegment4(deploymentId, "production");
+      const inboxRoot = import_node_path21.default.join(evidenceRoot, "inbox", safeDeploymentId);
+      const artifactsRoot = import_node_path21.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      await Promise.all([
+        import_promises26.default.mkdir(inboxRoot, { recursive: true }),
+        import_promises26.default.mkdir(artifactsRoot, { recursive: true })
+      ]);
+      const rsyncArgs = buildRuntimeEvidenceRsyncArgs({
+        source,
+        destination: inboxRoot
+      });
+      const transfer = await runRsync(rsyncArgs);
+      const discovered = await discoverRuntimeEvidenceBundles(inboxRoot);
+      const received = [];
+      for (const bundleDir of discovered) {
+        const verified = await verifyRuntimeEvidenceBundle(bundleDir);
+        if (verified.manifest.deploymentId !== safeDeploymentId) {
+          throw new Error(
+            `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
+          );
+        }
+        assertCurrentRuntimeEvidenceArtifact(verified.artifact);
+        const destinationDir = import_node_path21.default.join(
+          artifactsRoot,
+          ...dateParts2(verified.manifest.window.endTime),
+          safeSegment4(verified.manifest.artifactId, "artifact")
+        );
+        await import_promises26.default.mkdir(import_node_path21.default.dirname(destinationDir), { recursive: true });
+        try {
+          await import_promises26.default.rename(bundleDir, destinationDir);
+        } catch (error) {
+          if (!isExistingDestinationError2(error)) throw error;
+          const existing = await verifyRuntimeEvidenceBundle(destinationDir);
+          if (existing.manifest.payload.sha256 !== verified.manifest.payload.sha256) {
+            throw new Error(
+              `Conflicting runtime evidence artifact ${verified.manifest.artifactId}`
+            );
+          }
+          await import_promises26.default.rm(bundleDir, { recursive: true, force: true });
+        }
+        received.push(await verifyRuntimeEvidenceBundle(destinationDir));
+      }
+      const pending = await listPendingRuntimeEvidenceBundles({
+        evidenceRoot,
+        deploymentId: safeDeploymentId
+      });
+      return {
+        rsyncArgs,
+        stdout: String(transfer.stdout ?? ""),
+        stderr: String(transfer.stderr ?? ""),
+        received,
+        pending
+      };
+    };
+  }
+});
+
+// src/lib/runtimeFeedbackSync.ts
+var import_node_child_process8, import_promises27, import_node_path22, import_node_util2, execFileAsync2, isExistingDestinationError3, safeSegment5, dateParts3, syncRuntimeFeedbackReplayBundles;
+var init_runtimeFeedbackSync = __esm({
+  "src/lib/runtimeFeedbackSync.ts"() {
+    "use strict";
+    import_node_child_process8 = require("child_process");
+    import_promises27 = __toESM(require("fs/promises"));
+    import_node_path22 = __toESM(require("path"));
+    import_node_util2 = require("util");
+    init_runtimeFeedbackArtifacts();
+    init_runtimeEvidenceSync();
+    execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process8.execFile);
+    isExistingDestinationError3 = (error) => {
+      const code = error.code;
+      return code === "EEXIST" || code === "ENOTEMPTY";
+    };
+    safeSegment5 = (value, fallback) => {
+      const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+      return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
+    };
+    dateParts3 = (timestamp) => {
+      const date = new Date(timestamp);
+      return [
+        String(date.getUTCFullYear()),
+        String(date.getUTCMonth() + 1).padStart(2, "0"),
+        String(date.getUTCDate()).padStart(2, "0")
+      ];
+    };
+    syncRuntimeFeedbackReplayBundles = async ({
+      source,
+      feedbackRoot,
+      deploymentId,
+      runRsync = async (args37) => {
+        const result = await execFileAsync2("rsync", args37, {
+          maxBuffer: 10 * 1024 * 1024
+        });
+        return { stdout: result.stdout, stderr: result.stderr };
+      }
+    }) => {
+      const safeDeploymentId = safeSegment5(deploymentId, "production");
+      const inboxRoot = import_node_path22.default.join(feedbackRoot, "inbox", safeDeploymentId);
+      const artifactsRoot = import_node_path22.default.join(feedbackRoot, "artifacts", safeDeploymentId);
+      await Promise.all([
+        import_promises27.default.mkdir(inboxRoot, { recursive: true }),
+        import_promises27.default.mkdir(artifactsRoot, { recursive: true })
+      ]);
+      const rsyncArgs = buildRuntimeEvidenceRsyncArgs({
+        source,
+        destination: inboxRoot
+      });
+      const transfer = await runRsync(rsyncArgs);
+      const discovered = await discoverRuntimeFeedbackReplayBundles(inboxRoot);
+      const received = [];
+      for (const bundleDir of discovered) {
+        const verified = await verifyRuntimeFeedbackReplayBundle(bundleDir);
+        if (verified.manifest.deploymentId !== safeDeploymentId) {
+          throw new Error(
+            `Runtime feedback deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
+          );
+        }
+        const destinationDir = import_node_path22.default.join(
+          artifactsRoot,
+          ...dateParts3(verified.manifest.window.endTime),
+          safeSegment5(verified.manifest.runtimeEvidence.artifactId, "artifact"),
+          safeSegment5(verified.manifest.runId, "run")
+        );
+        await import_promises27.default.mkdir(import_node_path22.default.dirname(destinationDir), { recursive: true });
+        try {
+          await import_promises27.default.rename(bundleDir, destinationDir);
+        } catch (error) {
+          if (!isExistingDestinationError3(error)) throw error;
+          const existing = await verifyRuntimeFeedbackReplayBundle(destinationDir);
+          if (existing.manifest.payloads.replayEvidence.sha256 !== verified.manifest.payloads.replayEvidence.sha256) {
+            throw new Error(
+              `Conflicting runtime feedback replay ${verified.manifest.artifactId}`
+            );
+          }
+          await import_promises27.default.rm(bundleDir, { recursive: true, force: true });
+        }
+        received.push(await verifyRuntimeFeedbackReplayBundle(destinationDir));
+      }
+      return {
+        rsyncArgs,
+        stdout: String(transfer.stdout ?? ""),
+        stderr: String(transfer.stderr ?? ""),
+        received
+      };
+    };
+  }
+});
+
+// src/scripts/runtimeFeedbackSync.ts
+var runtimeFeedbackSync_exports = {};
+__export(runtimeFeedbackSync_exports, {
+  main: () => main35,
+  runtimeFeedbackSync: () => runtimeFeedbackSync
+});
+var import_node_path23, import_args27, import_chalk40, flags26, projectRoot10, runtimeFeedbackSync, main35;
+var init_runtimeFeedbackSync2 = __esm({
+  "src/scripts/runtimeFeedbackSync.ts"() {
+    "use strict";
+    import_node_path23 = __toESM(require("path"));
+    import_args27 = __toESM(require("args"));
+    import_chalk40 = __toESM(require("chalk"));
+    init_runtimeFeedbackSync();
+    import_args27.default.option(
+      "source",
+      "Rsync source ending at the runtime feedback ready directory",
+      process.env.RUNTIME_FEEDBACK_RSYNC_SOURCE
+    );
+    import_args27.default.option(
+      "deployment",
+      "Deployment id expected in runtime feedback manifests",
+      process.env.RUNTIME_EVIDENCE_DEPLOYMENT_ID || "production"
+    );
+    import_args27.default.option(
+      "dir",
+      "Local runtime feedback storage root",
+      process.env.RUNTIME_FEEDBACK_LOCAL_DIR || "data/runtime-feedback"
+    );
+    flags26 = import_args27.default.parse(process.argv);
+    projectRoot10 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    runtimeFeedbackSync = async () => {
+      const source = String(flags26.source ?? "").trim();
+      if (!source) {
+        throw new Error(
+          "Provide --source or RUNTIME_FEEDBACK_RSYNC_SOURCE for runtime feedback sync."
+        );
+      }
+      const feedbackRoot = import_node_path23.default.resolve(projectRoot10, String(flags26.dir));
+      const result = await syncRuntimeFeedbackReplayBundles({
+        source,
+        feedbackRoot,
+        deploymentId: String(flags26.deployment)
+      });
+      console.log(
+        import_chalk40.default.green(
+          `Runtime feedback sync completed: received=${result.received.length}`
+        )
+      );
+      console.log(
+        JSON.stringify(
+          {
+            feedbackRoot,
+            received: result.received.map((bundle) => ({
+              artifactId: bundle.manifest.artifactId,
+              bundleDir: bundle.bundleDir,
+              replayEvidencePath: bundle.replayEvidencePath,
+              runtimeEvidence: bundle.manifest.runtimeEvidence
+            }))
+          },
+          null,
+          2
+        )
+      );
+    };
+    main35 = runtimeFeedbackSync;
+  }
+});
+
 // src/lib/runtimeLineage.ts
-var import_node_crypto11, normalizeForStableJson2, resolveRuntimeMaxLossValue, fingerprintRuntimeValue, buildRuntimeLineage, runtimeLineageKey, runtimeLineagesMatch, runtimeLineagesComparable;
+var import_node_crypto13, normalizeForStableJson2, resolveRuntimeMaxLossValue, fingerprintRuntimeValue, buildRuntimeLineage, runtimeLineageKey, runtimeLineagesMatch, runtimeLineagesComparable;
 var init_runtimeLineage = __esm({
   "src/lib/runtimeLineage.ts"() {
     "use strict";
-    import_node_crypto11 = require("crypto");
+    import_node_crypto13 = require("crypto");
     normalizeForStableJson2 = (value) => {
       if (Array.isArray(value)) {
         return value.map(normalizeForStableJson2);
@@ -25636,7 +26612,7 @@ var init_runtimeLineage = __esm({
       );
       return Number.isFinite(maxLossValue) ? maxLossValue : null;
     };
-    fingerprintRuntimeValue = (value) => (0, import_node_crypto11.createHash)("sha256").update(JSON.stringify(normalizeForStableJson2(value))).digest("hex").slice(0, 16);
+    fingerprintRuntimeValue = (value) => (0, import_node_crypto13.createHash)("sha256").update(JSON.stringify(normalizeForStableJson2(value))).digest("hex").slice(0, 16);
     buildRuntimeLineage = async ({
       strategyRevision,
       deploymentCompositionId,
@@ -25687,50 +26663,51 @@ var init_runtimeLineage = __esm({
 // src/scripts/runtimeEvidence.ts
 var runtimeEvidence_exports = {};
 __export(runtimeEvidence_exports, {
-  main: () => main34,
+  main: () => main36,
   runtimeEvidence: () => runtimeEvidence
 });
-var import_promises23, import_node_path17, import_args26, import_chalk39, flags25, projectRoot9, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main34;
+var import_promises28, import_node_path24, import_args28, import_chalk41, flags27, projectRoot11, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main36;
 var init_runtimeEvidence = __esm({
   "src/scripts/runtimeEvidence.ts"() {
     "use strict";
-    import_promises23 = __toESM(require("fs/promises"));
-    import_node_path17 = __toESM(require("path"));
-    import_args26 = __toESM(require("args"));
-    import_chalk39 = __toESM(require("chalk"));
+    import_promises28 = __toESM(require("fs/promises"));
+    import_node_path24 = __toESM(require("path"));
+    import_args28 = __toESM(require("args"));
+    import_chalk41 = __toESM(require("chalk"));
     init_runtimeDebugEvidence();
     init_runtimeEvidenceArtifacts();
     init_runtimeLineage();
+    init_runtimeEvidenceProducer();
     init_runtimeEvidenceDeployment();
-    import_args26.default.option(["u", "user"], "Use user config", "root");
-    import_args26.default.option(
+    import_args28.default.option(["u", "user"], "Use user config", "root");
+    import_args28.default.option(
       ["S", "startTime"],
       "Window start timestamp, seconds/ms, or ISO date"
     );
-    import_args26.default.option(["E", "endTime"], "Window end timestamp, seconds/ms, or ISO date");
-    import_args26.default.option(
+    import_args28.default.option(["E", "endTime"], "Window end timestamp, seconds/ms, or ISO date");
+    import_args28.default.option(
       ["H", "hours"],
       "Fallback window in hours when start/end are omitted",
       24
     );
-    import_args26.default.option(
+    import_args28.default.option(
       "daily",
       "Use the latest complete 21:00 MSK to 21:00 MSK window",
       false
     );
-    import_args26.default.option(["s", "strategy"], "Strategy filter, comma-separated");
-    import_args26.default.option(["o", "out"], "Output JSON path", "output/runtime-evidence.json");
-    import_args26.default.option(
+    import_args28.default.option(["s", "strategy"], "Strategy filter, comma-separated");
+    import_args28.default.option(["o", "out"], "Output JSON path", "output/runtime-evidence.json");
+    import_args28.default.option(
       "publishDir",
       "Publish an immutable bundle under <dir>/ready/<deployment>"
     );
-    import_args26.default.option(
+    import_args28.default.option(
       "deployment",
       "Deployment id used by immutable evidence bundles",
       process.env.RUNTIME_EVIDENCE_DEPLOYMENT_ID || "production"
     );
-    flags25 = import_args26.default.parse(process.argv);
-    projectRoot9 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    flags27 = import_args28.default.parse(process.argv);
+    projectRoot11 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     toEpochMs3 = (value) => {
       if (value == null || value === "") {
         return null;
@@ -25744,11 +26721,11 @@ var init_runtimeEvidence = __esm({
       return Number.isFinite(parsed) ? parsed : null;
     };
     resolveWindow2 = () => {
-      const explicitStartTime = toEpochMs3(flags25.startTime);
-      const explicitEndTime = toEpochMs3(flags25.endTime);
+      const explicitStartTime = toEpochMs3(flags27.startTime);
+      const explicitEndTime = toEpochMs3(flags27.endTime);
       const now2 = Date.now();
       const dailyEndTime = (() => {
-        if (!flags25.daily || explicitStartTime != null || explicitEndTime != null) {
+        if (!flags27.daily || explicitStartTime != null || explicitEndTime != null) {
           return null;
         }
         const date = new Date(now2);
@@ -25763,7 +26740,7 @@ var init_runtimeEvidence = __esm({
       const endTime = explicitEndTime ?? dailyEndTime ?? now2;
       const hours = Math.max(
         1,
-        Number.parseInt(String(flags25.hours ?? 24), 10) || 24
+        Number.parseInt(String(flags27.hours ?? 24), 10) || 24
       );
       const startTime = explicitStartTime ?? endTime - hours * 60 * 60 * 1e3;
       if (startTime >= endTime) {
@@ -25780,16 +26757,21 @@ var init_runtimeEvidence = __esm({
     parseStrategyFilter2 = (value) => String(value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
     runtimeEvidence = async () => {
       const { startTime, endTime, source } = resolveWindow2();
-      const deploymentId = String(flags25.deployment);
+      const deploymentId = String(flags27.deployment);
+      const publishDir = String(flags27.publishDir ?? "").trim();
+      const producer = await resolveRuntimeEvidenceProducer({
+        projectRoot: projectRoot11,
+        required: Boolean(publishDir)
+      });
       const deploymentSnapshot = await resolveRuntimeEvidenceDeploymentSnapshot({
-        userName: String(flags25.user),
-        projectRoot: projectRoot9,
+        userName: String(flags27.user),
+        projectRoot: projectRoot11,
         deploymentId
       });
       const activeStrategies = activeRuntimeEvidenceStrategies(
         deploymentSnapshot
       ).map(({ strategyName }) => strategyName);
-      const requestedStrategies = parseStrategyFilter2(flags25.strategy);
+      const requestedStrategies = parseStrategyFilter2(flags27.strategy);
       const strategies = requestedStrategies.length ? requestedStrategies : activeStrategies;
       const declaredStrategies = new Set(
         deploymentSnapshot.strategies.map(({ strategyName }) => strategyName)
@@ -25803,7 +26785,7 @@ var init_runtimeEvidence = __esm({
         );
       }
       const evidence = await collectRuntimeDebugEvidence({
-        userName: flags25.user,
+        userName: flags27.user,
         startTime,
         endTime,
         strategies,
@@ -25837,7 +26819,7 @@ var init_runtimeEvidence = __esm({
         })
       );
       const runtime = buildRuntimeEvidenceReportPayload({
-        userName: flags25.user,
+        userName: flags27.user,
         startTime,
         endTime,
         signals: currentSignals,
@@ -25852,7 +26834,8 @@ var init_runtimeEvidence = __esm({
       const artifact = {
         reportType: "runtime-evidence",
         generatedAt: Date.now(),
-        userName: flags25.user,
+        ...producer ? { producer } : {},
+        userName: flags27.user,
         window: {
           startTime,
           endTime,
@@ -25864,15 +26847,14 @@ var init_runtimeEvidence = __esm({
         deployment,
         runtime
       };
-      const outPath = import_node_path17.default.resolve(projectRoot9, String(flags25.out));
-      await import_promises23.default.mkdir(import_node_path17.default.dirname(outPath), { recursive: true });
-      await import_promises23.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+      const outPath = import_node_path24.default.resolve(projectRoot11, String(flags27.out));
+      await import_promises28.default.mkdir(import_node_path24.default.dirname(outPath), { recursive: true });
+      await import_promises28.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
-      const publishDir = String(flags25.publishDir ?? "").trim();
       const published = publishDir ? await publishRuntimeEvidenceBundle({
-        publishRoot: import_node_path17.default.resolve(projectRoot9, publishDir),
+        publishRoot: import_node_path24.default.resolve(projectRoot11, publishDir),
         deploymentId,
-        userName: String(flags25.user),
+        userName: String(flags27.user),
         startTime,
         endTime,
         artifact,
@@ -25884,9 +26866,9 @@ var init_runtimeEvidence = __esm({
           ...currentLineageScopes.map((scope) => scope.lineage)
         ].filter((lineage) => lineage != null).map(runtimeLineageKey).filter((key, index, values) => values.indexOf(key) === index)
       }) : null;
-      console.log(import_chalk39.default.green(`Wrote ${outPath}`));
+      console.log(import_chalk41.default.green(`Wrote ${outPath}`));
       if (published) {
-        console.log(import_chalk39.default.green(`Published ${published.bundleDir}`));
+        console.log(import_chalk41.default.green(`Published ${published.bundleDir}`));
       }
       console.log(
         JSON.stringify(
@@ -25899,223 +26881,56 @@ var init_runtimeEvidence = __esm({
         )
       );
     };
-    main34 = runtimeEvidence;
-  }
-});
-
-// src/lib/runtimeEvidenceSync.ts
-var import_node_child_process6, import_promises24, import_node_path18, import_node_util, execFileAsync, isExistingDestinationError2, safeSegment2, withTrailingSlash, dateParts2, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
-var init_runtimeEvidenceSync = __esm({
-  "src/lib/runtimeEvidenceSync.ts"() {
-    "use strict";
-    import_node_child_process6 = require("child_process");
-    import_promises24 = __toESM(require("fs/promises"));
-    import_node_path18 = __toESM(require("path"));
-    import_node_util = require("util");
-    init_runtimeEvidenceArtifacts();
-    init_runtimeEvidenceDeployment();
-    execFileAsync = (0, import_node_util.promisify)(import_node_child_process6.execFile);
-    isExistingDestinationError2 = (error) => {
-      const code = error.code;
-      return code === "EEXIST" || code === "ENOTEMPTY";
-    };
-    safeSegment2 = (value, fallback) => {
-      const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
-      return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
-    };
-    withTrailingSlash = (value) => value.endsWith("/") ? value : `${value}/`;
-    dateParts2 = (timestamp) => {
-      const date = new Date(timestamp);
-      return [
-        String(date.getUTCFullYear()),
-        String(date.getUTCMonth() + 1).padStart(2, "0"),
-        String(date.getUTCDate()).padStart(2, "0")
-      ];
-    };
-    buildRuntimeEvidenceRsyncArgs = ({
-      source,
-      destination
-    }) => [
-      "--recursive",
-      "--times",
-      "--partial",
-      "--partial-dir=.rsync-partial",
-      "--prune-empty-dirs",
-      withTrailingSlash(source),
-      withTrailingSlash(destination)
-    ];
-    receiptPath = (receiptsRoot, artifactId) => import_node_path18.default.join(receiptsRoot, `${safeSegment2(artifactId, "artifact")}.json`);
-    compareBundles = (left, right) => left.manifest.window.endTime - right.manifest.window.endTime || left.manifest.createdAt - right.manifest.createdAt;
-    listPendingRuntimeEvidenceBundles = async ({
-      evidenceRoot,
-      deploymentId
-    }) => {
-      const safeDeploymentId = safeSegment2(deploymentId, "production");
-      const artifactsRoot = import_node_path18.default.join(evidenceRoot, "artifacts", safeDeploymentId);
-      const receiptsRoot = import_node_path18.default.join(evidenceRoot, "receipts", safeDeploymentId);
-      const bundles = await discoverRuntimeEvidenceBundles(artifactsRoot);
-      const pending = [];
-      for (const bundleDir of bundles) {
-        const verified = await verifyRuntimeEvidenceBundle(bundleDir);
-        if (verified.manifest.deploymentId !== safeDeploymentId) continue;
-        assertCurrentRuntimeEvidenceArtifact(verified.artifact);
-        try {
-          await import_promises24.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
-          continue;
-        } catch (error) {
-          if (error.code !== "ENOENT") throw error;
-        }
-        pending.push(verified);
-      }
-      return pending.sort(compareBundles);
-    };
-    markRuntimeEvidenceBundleProcessed = async ({
-      evidenceRoot,
-      deploymentId,
-      bundleDir,
-      scorecardPath
-    }) => {
-      const safeDeploymentId = safeSegment2(deploymentId, "production");
-      const verified = await verifyRuntimeEvidenceBundle(bundleDir);
-      if (verified.manifest.deploymentId !== safeDeploymentId) {
-        throw new Error(
-          `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
-        );
-      }
-      const receiptsRoot = import_node_path18.default.join(evidenceRoot, "receipts", safeDeploymentId);
-      const finalPath = receiptPath(receiptsRoot, verified.manifest.artifactId);
-      const temporaryPath = `${finalPath}.tmp-${process.pid}`;
-      const receipt = {
-        schemaVersion: 1,
-        artifactId: verified.manifest.artifactId,
-        payloadSha256: verified.manifest.payload.sha256,
-        processedAt: Date.now(),
-        scorecardPath: scorecardPath ?? null
-      };
-      await import_promises24.default.mkdir(receiptsRoot, { recursive: true });
-      await import_promises24.default.writeFile(
-        temporaryPath,
-        `${JSON.stringify(receipt, null, 2)}
-`,
-        "utf8"
-      );
-      await import_promises24.default.rename(temporaryPath, finalPath);
-      return finalPath;
-    };
-    syncRuntimeEvidenceBundles = async ({
-      source,
-      evidenceRoot,
-      deploymentId,
-      runRsync = async (args35) => {
-        const result = await execFileAsync("rsync", args35, {
-          maxBuffer: 10 * 1024 * 1024
-        });
-        return { stdout: result.stdout, stderr: result.stderr };
-      }
-    }) => {
-      const safeDeploymentId = safeSegment2(deploymentId, "production");
-      const inboxRoot = import_node_path18.default.join(evidenceRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path18.default.join(evidenceRoot, "artifacts", safeDeploymentId);
-      await Promise.all([
-        import_promises24.default.mkdir(inboxRoot, { recursive: true }),
-        import_promises24.default.mkdir(artifactsRoot, { recursive: true })
-      ]);
-      const rsyncArgs = buildRuntimeEvidenceRsyncArgs({
-        source,
-        destination: inboxRoot
-      });
-      const transfer = await runRsync(rsyncArgs);
-      const discovered = await discoverRuntimeEvidenceBundles(inboxRoot);
-      const received = [];
-      for (const bundleDir of discovered) {
-        const verified = await verifyRuntimeEvidenceBundle(bundleDir);
-        if (verified.manifest.deploymentId !== safeDeploymentId) {
-          throw new Error(
-            `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
-          );
-        }
-        assertCurrentRuntimeEvidenceArtifact(verified.artifact);
-        const destinationDir = import_node_path18.default.join(
-          artifactsRoot,
-          ...dateParts2(verified.manifest.window.endTime),
-          safeSegment2(verified.manifest.artifactId, "artifact")
-        );
-        await import_promises24.default.mkdir(import_node_path18.default.dirname(destinationDir), { recursive: true });
-        try {
-          await import_promises24.default.rename(bundleDir, destinationDir);
-        } catch (error) {
-          if (!isExistingDestinationError2(error)) throw error;
-          const existing = await verifyRuntimeEvidenceBundle(destinationDir);
-          if (existing.manifest.payload.sha256 !== verified.manifest.payload.sha256) {
-            throw new Error(
-              `Conflicting runtime evidence artifact ${verified.manifest.artifactId}`
-            );
-          }
-          await import_promises24.default.rm(bundleDir, { recursive: true, force: true });
-        }
-        received.push(await verifyRuntimeEvidenceBundle(destinationDir));
-      }
-      const pending = await listPendingRuntimeEvidenceBundles({
-        evidenceRoot,
-        deploymentId: safeDeploymentId
-      });
-      return {
-        rsyncArgs,
-        stdout: String(transfer.stdout ?? ""),
-        stderr: String(transfer.stderr ?? ""),
-        received,
-        pending
-      };
-    };
+    main36 = runtimeEvidence;
   }
 });
 
 // src/scripts/runtimeEvidenceSync.ts
 var runtimeEvidenceSync_exports = {};
 __export(runtimeEvidenceSync_exports, {
-  main: () => main35,
+  main: () => main37,
   runtimeEvidenceSync: () => runtimeEvidenceSync
 });
-var import_node_path19, import_args27, import_chalk40, flags26, projectRoot10, runtimeEvidenceSync, main35;
+var import_node_path25, import_args29, import_chalk42, flags28, projectRoot12, runtimeEvidenceSync, main37;
 var init_runtimeEvidenceSync2 = __esm({
   "src/scripts/runtimeEvidenceSync.ts"() {
     "use strict";
-    import_node_path19 = __toESM(require("path"));
-    import_args27 = __toESM(require("args"));
-    import_chalk40 = __toESM(require("chalk"));
+    import_node_path25 = __toESM(require("path"));
+    import_args29 = __toESM(require("args"));
+    import_chalk42 = __toESM(require("chalk"));
     init_runtimeEvidenceSync();
-    import_args27.default.option(
+    import_args29.default.option(
       "source",
       "Rsync source ending at the deployment ready directory",
       process.env.RUNTIME_EVIDENCE_RSYNC_SOURCE
     );
-    import_args27.default.option(
+    import_args29.default.option(
       "deployment",
       "Deployment id expected in artifact manifests",
       process.env.RUNTIME_EVIDENCE_DEPLOYMENT_ID || "production"
     );
-    import_args27.default.option(
+    import_args29.default.option(
       "dir",
       "Local evidence storage root",
       process.env.RUNTIME_EVIDENCE_LOCAL_DIR || "data/runtime-evidence"
     );
-    flags26 = import_args27.default.parse(process.argv);
-    projectRoot10 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    flags28 = import_args29.default.parse(process.argv);
+    projectRoot12 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     runtimeEvidenceSync = async () => {
-      const source = String(flags26.source ?? "").trim();
+      const source = String(flags28.source ?? "").trim();
       if (!source) {
         throw new Error(
           "Provide --source or RUNTIME_EVIDENCE_RSYNC_SOURCE for runtime evidence sync."
         );
       }
-      const evidenceRoot = import_node_path19.default.resolve(projectRoot10, String(flags26.dir));
+      const evidenceRoot = import_node_path25.default.resolve(projectRoot12, String(flags28.dir));
       const result = await syncRuntimeEvidenceBundles({
         source,
         evidenceRoot,
-        deploymentId: String(flags26.deployment)
+        deploymentId: String(flags28.deployment)
       });
       console.log(
-        import_chalk40.default.green(
+        import_chalk42.default.green(
           `Runtime evidence sync completed: received=${result.received.length} pending=${result.pending.length}`
         )
       );
@@ -26140,7 +26955,7 @@ var init_runtimeEvidenceSync2 = __esm({
         )
       );
     };
-    main35 = runtimeEvidenceSync;
+    main37 = runtimeEvidenceSync;
   }
 });
 
@@ -27112,7 +27927,7 @@ async function collectReleaseEvidenceReferences(references) {
       let artifact;
       try {
         const parsed = JSON.parse(
-          await import_promises25.default.readFile(reference.path, "utf8")
+          await import_promises29.default.readFile(reference.path, "utf8")
         );
         assert3(
           parsed != null && typeof parsed === "object" && !Array.isArray(parsed),
@@ -27259,13 +28074,13 @@ async function collectReleaseEvidenceReferences(references) {
     })
   );
 }
-var import_node_crypto12, import_promises25, import_node_path20, import_types9, import_strategyReleaseEvidence2, SHA256_RE2, LINEAGE_FINGERPRINT_RE, STRATEGY_REVISION_RE, DEPLOYMENT_COMPOSITION_ID_RE, REQUIRED_LONG_WINDOWS, REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS, MIN_RECENT_DIRECTION_REPAIR_EVENTS, safeSegment3, compactTimestamp2, verifyFullPeriodChartArtifact, readVerifiedJsonArtifact, verifyResearchDecisionLineage, hasExactRuntimeTarget, deriveStrategyReleaseResearchDecision, canonicalStrategyReleaseJson, strategyReleaseSha256, assertFingerprint, assertLineageFingerprint, releaseReasons, deriveReleaseGates, verifyEvidenceComposition, createStrategyReleaseManifest, createStrategyReleaseEnvelope, verifyStrategyReleaseEnvelope, verifyStrategyEvidenceMarkerEnvelope, releaseMarkers, writeJsonAtomic2, publishStrategyRelease, publishStrategyLiveDiagnosis, finiteString3, finiteNumber6, finiteDirectionPolicy, uniqueStrings, incompleteEvidenceLineage, extractEvidenceLineage, verifyCompletedCoreResearchBundle;
+var import_node_crypto14, import_promises29, import_node_path26, import_types9, import_strategyReleaseEvidence2, SHA256_RE2, LINEAGE_FINGERPRINT_RE, STRATEGY_REVISION_RE, DEPLOYMENT_COMPOSITION_ID_RE, REQUIRED_LONG_WINDOWS, REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS, MIN_RECENT_DIRECTION_REPAIR_EVENTS, safeSegment6, compactTimestamp2, verifyFullPeriodChartArtifact, readVerifiedJsonArtifact, verifyResearchDecisionLineage, hasExactRuntimeTarget, deriveStrategyReleaseResearchDecision, canonicalStrategyReleaseJson, strategyReleaseSha256, assertFingerprint, assertLineageFingerprint, releaseReasons, deriveReleaseGates, verifyEvidenceComposition, createStrategyReleaseManifest, createStrategyReleaseEnvelope, verifyStrategyReleaseEnvelope, verifyStrategyEvidenceMarkerEnvelope, releaseMarkers, writeJsonAtomic2, publishStrategyRelease, publishStrategyLiveDiagnosis, finiteString3, finiteNumber6, finiteDirectionPolicy, uniqueStrings, incompleteEvidenceLineage, extractEvidenceLineage, verifyCompletedCoreResearchBundle;
 var init_strategyRelease = __esm({
   "src/lib/strategyRelease.ts"() {
     "use strict";
-    import_node_crypto12 = require("crypto");
-    import_promises25 = __toESM(require("fs/promises"));
-    import_node_path20 = __toESM(require("path"));
+    import_node_crypto14 = require("crypto");
+    import_promises29 = __toESM(require("fs/promises"));
+    import_node_path26 = __toESM(require("path"));
     import_types9 = require("@tradejs/types");
     import_strategyReleaseEvidence2 = require("@tradejs/infra/strategyReleaseEvidence");
     init_liveDiagnosis();
@@ -27278,17 +28093,17 @@ var init_strategyRelease = __esm({
     REQUIRED_LONG_WINDOWS = [1095, 1460, 1825];
     REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS = [365, 180, 90];
     MIN_RECENT_DIRECTION_REPAIR_EVENTS = 20;
-    safeSegment3 = import_strategyReleaseEvidence2.safeStrategyEvidenceSegment;
+    safeSegment6 = import_strategyReleaseEvidence2.safeStrategyEvidenceSegment;
     compactTimestamp2 = import_strategyReleaseEvidence2.compactStrategyEvidenceTimestamp;
     verifyFullPeriodChartArtifact = async (input) => {
       const artifact = input.chartArtifact;
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return false;
       try {
-        const artifactPath = import_node_path20.default.resolve(artifact.path);
+        const artifactPath = import_node_path26.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return false;
         }
-        const report = JSON.parse(await import_promises25.default.readFile(artifactPath, "utf8"));
+        const report = JSON.parse(await import_promises29.default.readFile(artifactPath, "utf8"));
         return Boolean(
           report.chart?.persisted === true && report.chart.cardIds?.length && report.errors?.failed === 0 && report.run?.strategy === input.strategy && report.run.mode === "local-deterministic" && report.run.recent === 0 && report.run.since == null && report.run.until == null && Number(report.run.sourceRows) > 0
         );
@@ -27299,11 +28114,11 @@ var init_strategyRelease = __esm({
     readVerifiedJsonArtifact = async (artifact) => {
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return null;
       try {
-        const artifactPath = import_node_path20.default.resolve(artifact.path);
+        const artifactPath = import_node_path26.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return null;
         }
-        return JSON.parse(await import_promises25.default.readFile(artifactPath, "utf8"));
+        return JSON.parse(await import_promises29.default.readFile(artifactPath, "utf8"));
       } catch {
         return null;
       }
@@ -27794,7 +28609,7 @@ var init_strategyRelease = __esm({
         maxLossValue: input.composition.maxLossValue,
         ...input.composition.directionPolicy == null ? {} : { directionPolicy: input.composition.directionPolicy }
       };
-      const compositionId = `${safeSegment3(input.strategy, "strategy")}_${strategyReleaseSha256(compositionIdentity).slice(0, 16)}`;
+      const compositionId = `${safeSegment6(input.strategy, "strategy")}_${strategyReleaseSha256(compositionIdentity).slice(0, 16)}`;
       const reasons = releaseReasons({ ...input, gates: evidenceGates });
       const economicFailure = reasons.some(
         (reason) => [
@@ -27816,16 +28631,16 @@ var init_strategyRelease = __esm({
         strategy: input.strategy,
         createdAt: input.createdAt,
         compositionId,
-        evidence: input.evidence.map(({ kind, artifactId, sha256: sha2562 }) => ({
+        evidence: input.evidence.map(({ kind, artifactId, sha256: sha2564 }) => ({
           kind,
           artifactId,
-          sha256: sha2562
+          sha256: sha2564
         })),
         verdict
       };
       return {
         schema: import_types9.STRATEGY_RELEASE_SCHEMA,
-        releaseId: `${safeSegment3(input.strategy, "strategy")}_${compactTimestamp2(input.createdAt)}_${strategyReleaseSha256(releaseIdentity).slice(0, 16)}`,
+        releaseId: `${safeSegment6(input.strategy, "strategy")}_${compactTimestamp2(input.createdAt)}_${strategyReleaseSha256(releaseIdentity).slice(0, 16)}`,
         strategy: input.strategy,
         createdAt: input.createdAt,
         composition: { ...input.composition, compositionId },
@@ -27849,7 +28664,7 @@ var init_strategyRelease = __esm({
       manifest
     });
     verifyStrategyReleaseEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises25.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises29.default.readFile(valueOrPath, "utf8")) : valueOrPath;
       const envelope = value;
       assert3(
         envelope?.schema === "tradejs-strategy-release-envelope/v1",
@@ -27900,7 +28715,7 @@ var init_strategyRelease = __esm({
       return envelope;
     };
     verifyStrategyEvidenceMarkerEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises25.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises29.default.readFile(valueOrPath, "utf8")) : valueOrPath;
       return (0, import_strategyReleaseEvidence2.verifyStrategyEvidenceMarkerEnvelope)(value);
     };
     releaseMarkers = (manifest) => {
@@ -27962,14 +28777,14 @@ var init_strategyRelease = __esm({
     };
     writeJsonAtomic2 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises25.default.mkdir(import_node_path20.default.dirname(filePath), { recursive: true });
-      await import_promises25.default.writeFile(
+      await import_promises29.default.mkdir(import_node_path26.default.dirname(filePath), { recursive: true });
+      await import_promises29.default.writeFile(
         temporaryPath,
         `${canonicalStrategyReleaseJson(value)}
 `,
         "utf8"
       );
-      await import_promises25.default.rename(temporaryPath, filePath);
+      await import_promises29.default.rename(temporaryPath, filePath);
     };
     publishStrategyRelease = async ({
       rootDir,
@@ -27986,16 +28801,16 @@ var init_strategyRelease = __esm({
           path: entry.path
         }))
       });
-      const releasePath = import_node_path20.default.join(
+      const releasePath = import_node_path26.default.join(
         rootDir,
         "releases",
-        safeSegment3(manifest.strategy, "strategy"),
+        safeSegment6(manifest.strategy, "strategy"),
         `${manifest.releaseId}.json`
       );
-      const markerPath = import_node_path20.default.join(
+      const markerPath = import_node_path26.default.join(
         rootDir,
         "markers",
-        safeSegment3(manifest.strategy, "strategy"),
+        safeSegment6(manifest.strategy, "strategy"),
         `${markerEnvelope.artifactId}.json`
       );
       await Promise.all([
@@ -28015,7 +28830,7 @@ var init_strategyRelease = __esm({
       composition
     }) => {
       const diagnosisSha256 = strategyReleaseSha256(diagnosis);
-      const diagnosisId = `${safeSegment3(diagnosis.strategy, "strategy")}_${compactTimestamp2(diagnosis.createdAt)}_${diagnosisSha256.slice(0, 16)}`;
+      const diagnosisId = `${safeSegment6(diagnosis.strategy, "strategy")}_${compactTimestamp2(diagnosis.createdAt)}_${diagnosisSha256.slice(0, 16)}`;
       const envelope = {
         schema: "tradejs-strategy-live-diagnosis-envelope/v1",
         diagnosisId,
@@ -28072,16 +28887,16 @@ var init_strategyRelease = __esm({
         markers,
         sourceArtifacts
       });
-      const diagnosisPath = import_node_path20.default.join(
+      const diagnosisPath = import_node_path26.default.join(
         rootDir,
         "diagnoses",
-        safeSegment3(diagnosis.strategy, "strategy"),
+        safeSegment6(diagnosis.strategy, "strategy"),
         `${diagnosisId}.json`
       );
-      const markerPath = import_node_path20.default.join(
+      const markerPath = import_node_path26.default.join(
         rootDir,
         "markers",
-        safeSegment3(diagnosis.strategy, "strategy"),
+        safeSegment6(diagnosis.strategy, "strategy"),
         `${markerEnvelope.artifactId}.json`
       );
       await Promise.all([
@@ -28268,11 +29083,11 @@ var init_strategyRelease = __esm({
       const specSha256 = finiteString3(artifact.specSha256);
       assert3(researchId != null, "core result researchId is required");
       assert3(specSha256 != null, "core result specSha256 is required");
-      const researchDir = import_node_path20.default.dirname(resultPath);
-      const manifestPath = import_node_path20.default.join(researchDir, "manifest.json");
-      const specPath = import_node_path20.default.join(researchDir, "spec.json");
-      const manifestBytes = await import_promises25.default.readFile(manifestPath).catch(() => null);
-      const specBytes = await import_promises25.default.readFile(specPath).catch(() => null);
+      const researchDir = import_node_path26.default.dirname(resultPath);
+      const manifestPath = import_node_path26.default.join(researchDir, "manifest.json");
+      const specPath = import_node_path26.default.join(researchDir, "spec.json");
+      const manifestBytes = await import_promises29.default.readFile(manifestPath).catch(() => null);
+      const specBytes = await import_promises29.default.readFile(specPath).catch(() => null);
       assert3(
         manifestBytes != null && specBytes != null,
         "core result must belong to a completed core research bundle"
@@ -28281,14 +29096,14 @@ var init_strategyRelease = __esm({
       const artifactHashes = manifest.artifactHashes != null && typeof manifest.artifactHashes === "object" && !Array.isArray(manifest.artifactHashes) ? manifest.artifactHashes : null;
       const parsedSpec = JSON.parse(specBytes.toString("utf8"));
       assert3(
-        manifest.schema === "tradejs-core-research-manifest/v1" && manifest.status === "completed" && manifest.researchId === researchId && manifest.specSha256 === specSha256 && artifactHashes?.["result.json"] === resultSha256 && (0, import_node_crypto12.createHash)("sha256").update(canonicalStrategyReleaseJson(parsedSpec)).digest("hex") === specSha256,
+        manifest.schema === "tradejs-core-research-manifest/v1" && manifest.status === "completed" && manifest.researchId === researchId && manifest.specSha256 === specSha256 && artifactHashes?.["result.json"] === resultSha256 && (0, import_node_crypto14.createHash)("sha256").update(canonicalStrategyReleaseJson(parsedSpec)).digest("hex") === specSha256,
         "core result is not bound by its completed core research manifest"
       );
       for (const [relativePath, expectedSha256] of Object.entries(
         artifactHashes ?? {}
       )) {
         assert3(
-          !import_node_path20.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
+          !import_node_path26.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
           `core bundle artifact ${relativePath} escapes its research directory`
         );
         assert3(
@@ -28296,7 +29111,7 @@ var init_strategyRelease = __esm({
           `core bundle artifact ${relativePath} has an invalid checksum`
         );
         const actualSha256 = await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(
-          import_node_path20.default.join(researchDir, relativePath)
+          import_node_path26.default.join(researchDir, relativePath)
         );
         assert3(
           actualSha256 === expectedSha256,
@@ -28310,88 +29125,89 @@ var init_strategyRelease = __esm({
 // src/scripts/runtimeScorecard.ts
 var runtimeScorecard_exports = {};
 __export(runtimeScorecard_exports, {
-  main: () => main36,
+  main: () => main38,
   runtimeScorecard: () => runtimeScorecard
 });
-var import_promises26, import_node_crypto13, import_node_path21, import_args28, import_chalk41, flags27, projectRoot11, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main36;
+var import_promises30, import_node_crypto15, import_node_path27, import_args30, import_chalk43, flags29, projectRoot13, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main38;
 var init_runtimeScorecard2 = __esm({
   "src/scripts/runtimeScorecard.ts"() {
     "use strict";
-    import_promises26 = __toESM(require("fs/promises"));
-    import_node_crypto13 = require("crypto");
-    import_node_path21 = __toESM(require("path"));
-    import_args28 = __toESM(require("args"));
-    import_chalk41 = __toESM(require("chalk"));
+    import_promises30 = __toESM(require("fs/promises"));
+    import_node_crypto15 = require("crypto");
+    import_node_path27 = __toESM(require("path"));
+    import_args30 = __toESM(require("args"));
+    import_chalk43 = __toESM(require("chalk"));
     init_runtimeEvidenceArtifacts();
+    init_runtimeFeedbackArtifacts();
     init_runtimeEvidenceSync();
     init_runtimeScorecard();
     init_strategyRelease();
-    import_args28.default.option(["u", "runtimeEvidence"], "Verified runtime evidence JSON");
-    import_args28.default.option(["r", "replayEvidence"], "Replay runtime evidence JSON");
-    import_args28.default.option(["c", "calibration"], "Execution calibration JSON");
-    import_args28.default.option(
+    import_args30.default.option(["u", "runtimeEvidence"], "Verified runtime evidence JSON");
+    import_args30.default.option(["r", "replayEvidence"], "Replay runtime evidence JSON");
+    import_args30.default.option(["c", "calibration"], "Execution calibration JSON");
+    import_args30.default.option(
       ["q", "prospectiveEvidence"],
       "Verified prospective raw-core/gate/regime summary JSON"
     );
-    import_args28.default.option(["s", "strategy"], "Exact strategy to isolate in the scorecard");
-    import_args28.default.option(
+    import_args30.default.option(["s", "strategy"], "Exact strategy to isolate in the scorecard");
+    import_args30.default.option(
       ["H", "historyDir"],
       "Directory containing verified evidence bundles"
     );
-    import_args28.default.option(
+    import_args30.default.option(
       ["E", "evidenceDir"],
       "Local evidence storage root used for processing receipts",
       process.env.RUNTIME_EVIDENCE_LOCAL_DIR || "data/runtime-evidence"
     );
-    import_args28.default.option(
+    import_args30.default.option(
       ["d", "deployment"],
       "Deployment id used for processing receipts",
       process.env.RUNTIME_EVIDENCE_DEPLOYMENT_ID || "production"
     );
-    import_args28.default.option(
+    import_args30.default.option(
       ["M", "markProcessed"],
       "Write a processing receipt on success",
       false
     );
-    import_args28.default.option(
+    import_args30.default.option(
       ["P", "minimumParityRatio"],
       "Minimum acceptable replay parity",
       0.95
     );
-    import_args28.default.option(
+    import_args30.default.option(
       ["S", "maximumSlippageResidualBps"],
       "Maximum acceptable execution residual in bps",
       3
     );
-    import_args28.default.option(
+    import_args30.default.option(
       ["T", "minimumClosedTrades"],
       "Minimum 7d closed trades for expectancy reactions",
       20
     );
-    import_args28.default.option(["X", "minimumExpectancy"], "Minimum acceptable 7d expectancy", 0);
-    import_args28.default.option(["o", "out"], "Output JSON path", "output/runtime-scorecard.json");
-    import_args28.default.option(
+    import_args30.default.option(["X", "minimumExpectancy"], "Minimum acceptable 7d expectancy", 0);
+    import_args30.default.option(["o", "out"], "Output JSON path", "output/runtime-scorecard.json");
+    import_args30.default.option(
       ["m", "releaseManifest"],
       "Verified strategy release envelope JSON"
     );
-    import_args28.default.option(["D", "diagnosisDays"], "Equal-length release drawdown window", 7);
-    import_args28.default.option(
+    import_args30.default.option(["D", "diagnosisDays"], "Equal-length release drawdown window", 7);
+    import_args30.default.option(
       ["z", "strategyReleaseRoot"],
       "Publish advisory diagnosis and immutable chart markers under this root"
     );
-    flags27 = import_args28.default.parse(process.argv);
-    projectRoot11 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    flags29 = import_args30.default.parse(process.argv);
+    projectRoot13 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     resolveOptionalPath = (value) => {
       const raw = String(value ?? "").trim();
-      return raw ? import_node_path21.default.resolve(projectRoot11, raw) : null;
+      return raw ? import_node_path27.default.resolve(projectRoot13, raw) : null;
     };
-    readJson = async (filePath) => filePath ? JSON.parse(await import_promises26.default.readFile(filePath, "utf8")) : void 0;
+    readJson = async (filePath) => filePath ? JSON.parse(await import_promises30.default.readFile(filePath, "utf8")) : void 0;
     assertReportType = (artifact, expected, label) => {
       if (artifact != null && (!artifact || typeof artifact !== "object" || Array.isArray(artifact) || artifact.reportType !== expected)) {
         throw new Error(`${label} must be a ${expected} artifact`);
       }
     };
-    sha256File2 = async (filePath) => (0, import_node_crypto13.createHash)("sha256").update(await import_promises26.default.readFile(filePath)).digest("hex");
+    sha256File2 = async (filePath) => (0, import_node_crypto15.createHash)("sha256").update(await import_promises30.default.readFile(filePath)).digest("hex");
     loadHistoryArtifacts = async (historyDir) => {
       if (!historyDir) return [];
       const bundleDirs = await discoverRuntimeEvidenceBundles(historyDir);
@@ -28402,17 +29218,17 @@ var init_runtimeScorecard2 = __esm({
       return bundles.map((bundle) => bundle.artifact);
     };
     runtimeScorecard = async () => {
-      const runtimeEvidencePath = resolveOptionalPath(flags27.runtimeEvidence);
+      const runtimeEvidencePath = resolveOptionalPath(flags29.runtimeEvidence);
       if (!runtimeEvidencePath) {
         throw new Error("Provide --runtimeEvidence for the runtime scorecard.");
       }
-      const replayEvidencePath = resolveOptionalPath(flags27.replayEvidence);
-      const calibrationPath = resolveOptionalPath(flags27.calibration);
+      const replayEvidencePath = resolveOptionalPath(flags29.replayEvidence);
+      const calibrationPath = resolveOptionalPath(flags29.calibration);
       const prospectiveEvidencePath = resolveOptionalPath(
-        flags27.prospectiveEvidence
+        flags29.prospectiveEvidence
       );
-      const historyDir = resolveOptionalPath(flags27.historyDir);
-      const releaseManifestPath = resolveOptionalPath(flags27.releaseManifest);
+      const historyDir = resolveOptionalPath(flags29.historyDir);
+      const releaseManifestPath = resolveOptionalPath(flags29.releaseManifest);
       const [
         runtimeArtifact,
         replayEvidenceArtifact,
@@ -28439,7 +29255,7 @@ var init_runtimeScorecard2 = __esm({
         "prospectiveEvidence"
       );
       const verifiedRelease = releaseManifestPath ? await verifyStrategyReleaseEnvelope(releaseManifestPath) : null;
-      const requestedStrategy = String(flags27.strategy ?? "").trim() || null;
+      const requestedStrategy = String(flags29.strategy ?? "").trim() || null;
       if (verifiedRelease && requestedStrategy && requestedStrategy !== verifiedRelease.manifest.strategy) {
         throw new Error(
           `Requested strategy ${requestedStrategy} does not match release ${verifiedRelease.manifest.strategy}`
@@ -28453,21 +29269,21 @@ var init_runtimeScorecard2 = __esm({
         prospectiveEvidenceArtifact,
         historyRuntimeArtifacts: history,
         thresholds: {
-          minimumParityRatio: Number(flags27.minimumParityRatio),
-          maximumSlippageResidualBps: Number(flags27.maximumSlippageResidualBps),
-          minimumClosedTrades: Number(flags27.minimumClosedTrades),
-          minimumExpectancy: Number(flags27.minimumExpectancy)
+          minimumParityRatio: Number(flags29.minimumParityRatio),
+          maximumSlippageResidualBps: Number(flags29.maximumSlippageResidualBps),
+          minimumClosedTrades: Number(flags29.minimumClosedTrades),
+          minimumExpectancy: Number(flags29.minimumExpectancy)
         },
         strategy: scorecardStrategy,
         llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
       });
-      const outPath = import_node_path21.default.resolve(projectRoot11, String(flags27.out));
+      const outPath = import_node_path27.default.resolve(projectRoot13, String(flags29.out));
       const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
-      await import_promises26.default.mkdir(import_node_path21.default.dirname(outPath), { recursive: true });
+      await import_promises30.default.mkdir(import_node_path27.default.dirname(outPath), { recursive: true });
       await Promise.all([
-        import_promises26.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
+        import_promises30.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
-        import_promises26.default.writeFile(
+        import_promises30.default.writeFile(
           markdownPath,
           formatRuntimeScorecardMarkdown(scorecard),
           "utf8"
@@ -28476,12 +29292,12 @@ var init_runtimeScorecard2 = __esm({
       const diagnosis = verifiedRelease ? buildStrategyLiveDiagnosisFromScorecard({
         manifest: verifiedRelease.manifest,
         scorecard,
-        days: Number(flags27.diagnosisDays)
+        days: Number(flags29.diagnosisDays)
       }) : null;
       const diagnosisPath = diagnosis ? outPath.replace(/\.json$/i, "") + ".diagnosis.json" : null;
-      const strategyReleaseRoot = resolveOptionalPath(flags27.strategyReleaseRoot);
+      const strategyReleaseRoot = resolveOptionalPath(flags29.strategyReleaseRoot);
       if (diagnosis && diagnosisPath) {
-        await import_promises26.default.writeFile(
+        await import_promises30.default.writeFile(
           diagnosisPath,
           `${JSON.stringify(diagnosis, null, 2)}
 `,
@@ -28502,7 +29318,7 @@ var init_runtimeScorecard2 = __esm({
             composition: verifiedRelease?.manifest.composition,
             sourceArtifacts: await Promise.all(
               sourcePaths.map(async (sourcePath) => ({
-                artifactId: import_node_path21.default.basename(sourcePath),
+                artifactId: import_node_path27.default.basename(sourcePath),
                 path: sourcePath,
                 sha256: await sha256File2(sourcePath)
               }))
@@ -28511,16 +29327,35 @@ var init_runtimeScorecard2 = __esm({
         }
       }
       let receiptPath2 = null;
-      if (flags27.markProcessed) {
+      if (flags29.markProcessed) {
+        const runtimeEvidenceBundle = await verifyRuntimeEvidenceBundle(
+          import_node_path27.default.dirname(runtimeEvidencePath)
+        );
+        const feedbackSource = replayEvidencePath ? await verifyRuntimeFeedbackReplaySource({
+          bundleDir: import_node_path27.default.dirname(replayEvidencePath),
+          runtimeEvidenceBundleDir: import_node_path27.default.dirname(runtimeEvidencePath)
+        }).catch((error) => {
+          if (runtimeEvidenceBundle.artifact.producer) throw error;
+          return null;
+        }) : null;
+        if (runtimeEvidenceBundle.artifact.producer && !feedbackSource) {
+          throw new Error(
+            "Image-bound runtime evidence requires a verified production replay bundle before it can be marked processed"
+          );
+        }
         receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-          evidenceRoot: import_node_path21.default.resolve(projectRoot11, String(flags27.evidenceDir)),
-          deploymentId: String(flags27.deployment),
-          bundleDir: import_node_path21.default.dirname(runtimeEvidencePath),
-          scorecardPath: outPath
+          evidenceRoot: import_node_path27.default.resolve(projectRoot13, String(flags29.evidenceDir)),
+          deploymentId: String(flags29.deployment),
+          bundleDir: import_node_path27.default.dirname(runtimeEvidencePath),
+          scorecardPath: outPath,
+          runtimeFeedback: feedbackSource ? {
+            artifactId: feedbackSource.feedback.manifest.artifactId,
+            replayEvidenceSha256: feedbackSource.feedback.manifest.payloads.replayEvidence.sha256
+          } : null
         });
       }
-      console.log(import_chalk41.default.green(`Wrote ${outPath}`));
-      console.log(import_chalk41.default.green(`Wrote ${markdownPath}`));
+      console.log(import_chalk43.default.green(`Wrote ${outPath}`));
+      console.log(import_chalk43.default.green(`Wrote ${markdownPath}`));
       console.log(
         JSON.stringify(
           {
@@ -28539,7 +29374,7 @@ var init_runtimeScorecard2 = __esm({
         )
       );
     };
-    main36 = runtimeScorecard;
+    main38 = runtimeScorecard;
   }
 });
 
@@ -28547,10 +29382,10 @@ var init_runtimeScorecard2 = __esm({
 var runtimeControl_exports = {};
 __export(runtimeControl_exports, {
   RUNTIME_CONTROL_ACTIONS: () => RUNTIME_CONTROL_ACTIONS,
-  main: () => main37,
+  main: () => main39,
   runtimeControl: () => runtimeControl
 });
-var import_config9, import_runtimeControls, import_runtimeStrategies4, argv, RUNTIME_CONTROL_ACTIONS, action, option, required2, projectRoot12, userName2, verify, inspect, updateControlState, runtimeControl, main37;
+var import_config9, import_runtimeControls, import_runtimeStrategies4, argv, RUNTIME_CONTROL_ACTIONS, action, option, required2, projectRoot14, userName2, verify, inspect, updateControlState, runtimeControl, main39;
 var init_runtimeControl = __esm({
   "src/scripts/runtimeControl.ts"() {
     "use strict";
@@ -28574,10 +29409,10 @@ var init_runtimeControl = __esm({
       if (!value) throw new Error(`--${name} is required`);
       return value;
     };
-    projectRoot12 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    projectRoot14 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     userName2 = String(option("user") ?? process.env.USER_NAME ?? "root");
     verify = async () => {
-      const deployments = await (0, import_runtimeStrategies4.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot12 });
+      const deployments = await (0, import_runtimeStrategies4.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot14 });
       const requestedDeployment = option("deployment");
       const selected = requestedDeployment ? deployments.filter((deployment) => deployment.id === requestedDeployment) : deployments;
       if (requestedDeployment && !selected.length) {
@@ -28588,7 +29423,7 @@ var init_runtimeControl = __esm({
         try {
           const strategies = await (0, import_runtimeStrategies4.loadResolvedRuntimeStrategies)({
             userName: userName2,
-            projectRoot: projectRoot12,
+            projectRoot: projectRoot14,
             deploymentId: deployment.id
           });
           results2.push({
@@ -28621,7 +29456,7 @@ var init_runtimeControl = __esm({
     inspect = async () => {
       const requestedDeployment = option("deployment");
       const requestedStrategy = option("strategy");
-      const deployments = (await (0, import_runtimeStrategies4.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot12 })).filter(
+      const deployments = (await (0, import_runtimeStrategies4.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot14 })).filter(
         (deployment) => !requestedDeployment || deployment.id === requestedDeployment
       ).map((deployment) => ({
         ...deployment,
@@ -28636,7 +29471,7 @@ var init_runtimeControl = __esm({
       const strategyName = required2("strategy");
       const deployment = await (0, import_runtimeStrategies4.getRuntimeDeployment)({
         userName: userName2,
-        projectRoot: projectRoot12,
+        projectRoot: projectRoot14,
         deploymentId
       });
       if (!deployment) {
@@ -28666,7 +29501,7 @@ var init_runtimeControl = __esm({
       }
       const updated = await (0, import_runtimeStrategies4.getRuntimeDeployment)({
         userName: userName2,
-        projectRoot: projectRoot12,
+        projectRoot: projectRoot14,
         deploymentId
       });
       const updatedReference = updated?.strategies.find(
@@ -28698,25 +29533,25 @@ var init_runtimeControl = __esm({
         `Usage: tradejs runtime-control ${RUNTIME_CONTROL_ACTIONS.join("|")}`
       );
     };
-    main37 = runtimeControl;
+    main39 = runtimeControl;
   }
 });
 
 // src/scripts/strategyRelease.ts
 var strategyRelease_exports = {};
 __export(strategyRelease_exports, {
-  main: () => main38,
+  main: () => main40,
   runStrategyReleaseCommand: () => runStrategyReleaseCommand
 });
-var import_promises27, import_node_fs5, import_node_readline2, import_node_path22, import_chalk42, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main38;
+var import_promises31, import_node_fs5, import_node_readline2, import_node_path28, import_chalk44, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main40;
 var init_strategyRelease2 = __esm({
   "src/scripts/strategyRelease.ts"() {
     "use strict";
-    import_promises27 = __toESM(require("fs/promises"));
+    import_promises31 = __toESM(require("fs/promises"));
     import_node_fs5 = require("fs");
     import_node_readline2 = require("readline");
-    import_node_path22 = __toESM(require("path"));
-    import_chalk42 = __toESM(require("chalk"));
+    import_node_path28 = __toESM(require("path"));
+    import_chalk44 = __toESM(require("chalk"));
     init_strategyRelease();
     valueAfter2 = (argv2, name) => {
       const index = argv2.indexOf(name);
@@ -28728,17 +29563,17 @@ var init_strategyRelease2 = __esm({
     };
     writeJsonAtomic3 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises27.default.mkdir(import_node_path22.default.dirname(filePath), { recursive: true });
-      await import_promises27.default.writeFile(
+      await import_promises31.default.mkdir(import_node_path28.default.dirname(filePath), { recursive: true });
+      await import_promises31.default.writeFile(
         temporaryPath,
         `${JSON.stringify(value, null, 2)}
 `,
         "utf8"
       );
-      await import_promises27.default.rename(temporaryPath, filePath);
+      await import_promises31.default.rename(temporaryPath, filePath);
     };
     runStrategyReleaseCommand = async (options) => {
-      const inputPath = import_node_path22.default.resolve(options.inputPath);
+      const inputPath = import_node_path28.default.resolve(options.inputPath);
       if (options.command === "verify") {
         const envelope = await verifyStrategyReleaseEnvelope(inputPath);
         return {
@@ -28776,7 +29611,7 @@ var init_strategyRelease2 = __esm({
           endTime,
           days: options.days?.length ? options.days : [7, 30, 90]
         });
-        const outputPath = import_node_path22.default.resolve(
+        const outputPath = import_node_path28.default.resolve(
           options.outputPath ?? "output/strategy-monitoring-profile.json"
         );
         await writeJsonAtomic3(outputPath, profile);
@@ -28787,22 +29622,22 @@ var init_strategyRelease2 = __esm({
           profile
         };
       }
-      const input = JSON.parse(await import_promises27.default.readFile(inputPath, "utf8"));
+      const input = JSON.parse(await import_promises31.default.readFile(inputPath, "utf8"));
       if (options.command === "decide") {
         const decision = await deriveStrategyReleaseResearchDecision(input);
         if (options.outputPath) {
-          await writeJsonAtomic3(import_node_path22.default.resolve(options.outputPath), decision);
+          await writeJsonAtomic3(import_node_path28.default.resolve(options.outputPath), decision);
         }
         return {
           kind: "decided",
           ...decision,
-          outputPath: options.outputPath ? import_node_path22.default.resolve(options.outputPath) : null
+          outputPath: options.outputPath ? import_node_path28.default.resolve(options.outputPath) : null
         };
       }
       if (options.command === "retention") {
         const plan = planStrategyEvidenceRetention(input);
         if (options.apply) {
-          await Promise.all(plan.delete.map((entry) => import_promises27.default.rm(entry.path)));
+          await Promise.all(plan.delete.map((entry) => import_promises31.default.rm(entry.path)));
         }
         return {
           kind: "retention",
@@ -28815,12 +29650,12 @@ var init_strategyRelease2 = __esm({
       }
       if (options.command === "diagnose") {
         const diagnosis = buildStrategyLiveDiagnosis(input);
-        const outputPath = import_node_path22.default.resolve(
+        const outputPath = import_node_path28.default.resolve(
           options.outputPath ?? "output/strategy-live-diagnosis.json"
         );
         await writeJsonAtomic3(outputPath, diagnosis);
         const published2 = options.rootDir ? await publishStrategyLiveDiagnosis({
-          rootDir: import_node_path22.default.resolve(options.rootDir),
+          rootDir: import_node_path28.default.resolve(options.rootDir),
           diagnosis,
           sourceArtifacts: input.sourceArtifacts ?? []
         }) : null;
@@ -28837,7 +29672,7 @@ var init_strategyRelease2 = __esm({
         evidence: await collectReleaseEvidenceReferences(input.evidence ?? [])
       });
       const published = await publishStrategyRelease({
-        rootDir: import_node_path22.default.resolve(options.rootDir ?? "data/strategy-release"),
+        rootDir: import_node_path28.default.resolve(options.rootDir ?? "data/strategy-release"),
         manifest
       });
       return {
@@ -28855,7 +29690,7 @@ var init_strategyRelease2 = __esm({
   yarn strategy:release profile --input <trades.jsonl> --variant <id> --startTime <ms> --endTime <ms> [--days 7,30,90] [--out <profile.json>]
   yarn strategy:release diagnose --input <diagnosis-input.json> [--out output/diagnosis.json]
   yarn strategy:release retention --input <inventory.json> [--apply]`);
-    main38 = async () => {
+    main40 = async () => {
       const argv2 = process.argv.slice(2);
       const command = argv2[0];
       if (!command || ![
@@ -28881,7 +29716,7 @@ var init_strategyRelease2 = __esm({
         endTime: Number(valueAfter2(argv2, "--endTime")),
         days: valueAfter2(argv2, "--days")?.split(",").map((entry) => Number(entry.trim()))
       });
-      console.log(import_chalk42.default.green(JSON.stringify(result, null, 2)));
+      console.log(import_chalk44.default.green(JSON.stringify(result, null, 2)));
     };
   }
 });
@@ -28894,18 +29729,18 @@ __export(serverHealth_exports, {
   buildServerHealthDiagnostics: () => buildServerHealthDiagnostics,
   collectServerHealthSnapshot: () => collectServerHealthSnapshot,
   evaluateServerHealth: () => evaluateServerHealth,
-  main: () => main39,
+  main: () => main41,
   resolveServerHealthThresholds: () => resolveServerHealthThresholds
 });
-var import_config10, import_node_child_process7, import_node_os3, import_node_fs6, import_args29, import_redis16, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml4, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main39;
+var import_config10, import_node_child_process9, import_node_os3, import_node_fs6, import_args31, import_redis16, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml4, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main41;
 var init_serverHealth = __esm({
   "src/scripts/serverHealth.ts"() {
     "use strict";
     import_config10 = require("dotenv/config");
-    import_node_child_process7 = require("child_process");
+    import_node_child_process9 = require("child_process");
     import_node_os3 = __toESM(require("os"));
     import_node_fs6 = require("fs");
-    import_args29 = __toESM(require("args"));
+    import_args31 = __toESM(require("args"));
     import_redis16 = require("@tradejs/infra/redis");
     init_telegramReports();
     DEFAULT_STATE = {
@@ -28939,21 +29774,21 @@ var init_serverHealth = __esm({
       }
       return `${minutes}m`;
     };
-    readDiskUsage = (path35) => {
+    readDiskUsage = (path41) => {
       try {
-        const stats = (0, import_node_fs6.statfsSync)(path35);
+        const stats = (0, import_node_fs6.statfsSync)(path41);
         const totalBlocks = Number(stats.blocks ?? 0);
         const availableBlocks = Number(stats.bavail ?? 0);
         if (totalBlocks <= 0) {
-          return { path: path35, usedPct: null };
+          return { path: path41, usedPct: null };
         }
         const usedPct = (totalBlocks - Math.max(0, availableBlocks)) / totalBlocks * 100;
         return {
-          path: path35,
+          path: path41,
           usedPct: Number.isFinite(usedPct) ? usedPct : null
         };
       } catch {
-        return { path: path35, usedPct: null };
+        return { path: path41, usedPct: null };
       }
     };
     parseMeminfoBytes = (value) => {
@@ -29017,8 +29852,8 @@ var init_serverHealth = __esm({
         };
       }
     };
-    runDiagnosticCommand = (command, args35) => {
-      const output = (0, import_node_child_process7.execFileSync)(command, args35, {
+    runDiagnosticCommand = (command, args37) => {
+      const output = (0, import_node_child_process9.execFileSync)(command, args37, {
         encoding: "utf8",
         timeout: 5e3,
         maxBuffer: 1024 * 1024,
@@ -29268,57 +30103,57 @@ var init_serverHealth = __esm({
         diskRecoverPct: diskRecoverPct != null && diskRecoverPct > 0 ? diskRecoverPct : DEFAULT_THRESHOLDS.diskRecoverPct
       };
     };
-    import_args29.default.option(["u", "user"], "Use user config", "root");
-    import_args29.default.option(["P", "printOnly"], "Print report instead of Telegram", false);
-    import_args29.default.option(
+    import_args31.default.option(["u", "user"], "Use user config", "root");
+    import_args31.default.option(["P", "printOnly"], "Print report instead of Telegram", false);
+    import_args31.default.option(
       ["d", "diskPath"],
       "Filesystem path to inspect for disk pressure",
       "/"
     );
-    import_args29.default.option(
+    import_args31.default.option(
       ["c", "cooldownSec"],
       "Minimum seconds between repeated unhealthy reminders",
       900
     );
-    import_args29.default.option(
+    import_args31.default.option(
       ["l", "loadPerCpuWarn"],
       "Alert when 1m load per CPU reaches this value",
       String(DEFAULT_THRESHOLDS.loadPerCpuWarn)
     );
-    import_args29.default.option(
+    import_args31.default.option(
       ["L", "loadPerCpuRecover"],
       "Recovery threshold for 1m load per CPU",
       String(DEFAULT_THRESHOLDS.loadPerCpuRecover)
     );
-    import_args29.default.option(
+    import_args31.default.option(
       ["m", "memoryWarnPct"],
       "Alert when memory used percent reaches this value",
       String(DEFAULT_THRESHOLDS.memoryWarnPct)
     );
-    import_args29.default.option(
+    import_args31.default.option(
       ["M", "memoryRecoverPct"],
       "Recovery threshold for memory used percent",
       String(DEFAULT_THRESHOLDS.memoryRecoverPct)
     );
-    import_args29.default.option(
+    import_args31.default.option(
       ["D", "diskWarnPct"],
       "Alert when disk used percent reaches this value",
       String(DEFAULT_THRESHOLDS.diskWarnPct)
     );
-    import_args29.default.option(
+    import_args31.default.option(
       ["R", "diskRecoverPct"],
       "Recovery threshold for disk used percent",
       String(DEFAULT_THRESHOLDS.diskRecoverPct)
     );
-    main39 = async () => {
-      const flags32 = import_args29.default.parse(process.argv);
-      const thresholds = resolveServerHealthThresholds(flags32);
-      const diskPath = String(flags32.diskPath || "/");
+    main41 = async () => {
+      const flags34 = import_args31.default.parse(process.argv);
+      const thresholds = resolveServerHealthThresholds(flags34);
+      const diskPath = String(flags34.diskPath || "/");
       const snapshot = collectServerHealthSnapshot(diskPath);
-      const stateKey = getStateKey(String(flags32.user), snapshot.hostname);
+      const stateKey = getStateKey(String(flags34.user), snapshot.hostname);
       const prevState = await (0, import_redis16.getData)(stateKey, DEFAULT_STATE) ?? DEFAULT_STATE;
       const evaluation = evaluateServerHealth(snapshot, thresholds);
-      const cooldownMs = Math.max(60, Number(flags32.cooldownSec)) * 1e3;
+      const cooldownMs = Math.max(60, Number(flags34.cooldownSec)) * 1e3;
       const now2 = snapshot.timestamp;
       if (!evaluation.isHealthy) {
         const reminder = prevState.status === "alerting" && typeof prevState.lastAlertAt === "number" && now2 - prevState.lastAlertAt < cooldownMs ? false : prevState.status === "alerting";
@@ -29336,7 +30171,7 @@ var init_serverHealth = __esm({
             prevState,
             reminder
           });
-          if (flags32.printOnly) {
+          if (flags34.printOnly) {
             console.log(message);
             console.log("");
             console.log(
@@ -29346,7 +30181,7 @@ var init_serverHealth = __esm({
               })
             );
           } else {
-            await sendTelegramReport(message, { userName: flags32.user });
+            await sendTelegramReport(message, { userName: flags34.user });
           }
         }
         return;
@@ -29361,10 +30196,10 @@ var init_serverHealth = __esm({
       await (0, import_redis16.setData)(stateKey, nextState, { expire: 0 });
       if (recovered) {
         const message = buildRecoveryMessage({ snapshot, prevState });
-        if (flags32.printOnly) {
+        if (flags34.printOnly) {
           console.log(message);
         } else {
-          await sendTelegramReport(message, { userName: flags32.user });
+          await sendTelegramReport(message, { userName: flags34.user });
         }
       }
     };
@@ -30767,11 +31602,11 @@ var init_reportingJson = __esm({
 });
 
 // src/lib/runtimeParity/reportingTerminal.ts
-var import_chalk43, import_time8, DETAIL_LIMIT, buildRuntimeParityTerminalReport, writeRuntimeParityTerminalReport, printRuntimeDuplicateDetails, printClassifiedBacktestOnlyDetails, printClassifiedRuntimeOnlyDetails;
+var import_chalk45, import_time8, DETAIL_LIMIT, buildRuntimeParityTerminalReport, writeRuntimeParityTerminalReport, printRuntimeDuplicateDetails, printClassifiedBacktestOnlyDetails, printClassifiedRuntimeOnlyDetails;
 var init_reportingTerminal = __esm({
   "src/lib/runtimeParity/reportingTerminal.ts"() {
     "use strict";
-    import_chalk43 = __toESM(require("chalk"));
+    import_chalk45 = __toESM(require("chalk"));
     import_time8 = require("@tradejs/core/time");
     init_classification();
     init_reportingShared();
@@ -30780,7 +31615,7 @@ var init_reportingTerminal = __esm({
       const mismatchRows = buildMismatchSummaryRows(context);
       const strategyIssueRows = buildStrategyIssueRows(context.strategyRows);
       const lines = [
-        import_chalk43.default.cyan("TradeJS runtime parity"),
+        import_chalk45.default.cyan("TradeJS runtime parity"),
         `Window: ${(0, import_time8.formatUnix)(context.window.start)} -> ${(0, import_time8.formatUnix)(context.window.end)} (${context.window.source})`,
         `Connector: ${context.connectorName}`,
         `Replay env: ${context.replayEnv}${context.runtimeGatesEnabled ? " (runtime AI/ML gates enabled)" : " (core/backtest gates only)"}`,
@@ -30809,7 +31644,7 @@ var init_reportingTerminal = __esm({
         lines.push(`Runtime evaluations: ${context.runtimeSignalEvaluationsCount}`);
       }
       if (mismatchRows.length) {
-        lines.push("", import_chalk43.default.yellow("Signal mismatches"));
+        lines.push("", import_chalk45.default.yellow("Signal mismatches"));
         for (const item of mismatchRows.slice(0, context.detailLimit)) {
           lines.push(`- ${item.line}`);
         }
@@ -30819,14 +31654,14 @@ var init_reportingTerminal = __esm({
       }
       lines.push("");
       if (strategyIssueRows.length) {
-        lines.push(import_chalk43.default.cyan("Strategy issues"), ...strategyIssueRows);
+        lines.push(import_chalk45.default.cyan("Strategy issues"), ...strategyIssueRows);
       } else if (context.strategyRows.length) {
         lines.push(
           `Strategies: clean ${context.strategyRows.length}/${context.strategyRows.length}`
         );
       }
       if (context.runtimeGateWarningCounts.size && !context.runtimeGatesRequested) {
-        lines.push("", import_chalk43.default.yellow("Warnings"));
+        lines.push("", import_chalk45.default.yellow("Warnings"));
         for (const [strategy, count] of [
           ...context.runtimeGateWarningCounts.entries()
         ].sort(([left], [right]) => left.localeCompare(right))) {
@@ -30836,7 +31671,7 @@ var init_reportingTerminal = __esm({
         }
       }
       if (context.replayErrors.length) {
-        lines.push("", import_chalk43.default.red("Replay errors"));
+        lines.push("", import_chalk45.default.red("Replay errors"));
         for (const error of context.replayErrors.slice(0, context.detailLimit)) {
           lines.push(`- ${error.strategy} ${error.symbol}: ${error.message}`);
         }
@@ -30854,7 +31689,7 @@ var init_reportingTerminal = __esm({
     printRuntimeDuplicateDetails = (groups) => {
       if (!groups.length) return;
       console.log("");
-      console.log(import_chalk43.default.yellow("Runtime duplicates"));
+      console.log(import_chalk45.default.yellow("Runtime duplicates"));
       for (const group of groups.slice(0, DETAIL_LIMIT)) {
         const ids = group.entries.map((entry) => entry.orderId ?? entry.id);
         console.log(
@@ -30868,7 +31703,7 @@ var init_reportingTerminal = __esm({
     printClassifiedBacktestOnlyDetails = (classifiedEntries) => {
       if (!classifiedEntries.length) return;
       console.log("");
-      console.log(import_chalk43.default.yellow("Backtest only"));
+      console.log(import_chalk45.default.yellow("Backtest only"));
       for (const item of classifiedEntries.slice(0, DETAIL_LIMIT)) {
         const evidenceSuffix = item.signal ? ` signalId=${item.signal.signalId} signalDrift=${formatMinutes2(item.signalTimestampDiffMs ?? null)}` : item.evaluation ? ` evaluationId=${item.evaluation.evaluationId} evaluationDrift=${formatMinutes2(item.evaluationTimestampDiffMs ?? null)}` : "";
         const price = item.entry.price == null ? "n/a" : item.entry.price.toFixed(6);
@@ -30883,7 +31718,7 @@ var init_reportingTerminal = __esm({
     printClassifiedRuntimeOnlyDetails = (classifiedEntries) => {
       if (!classifiedEntries.length) return;
       console.log("");
-      console.log(import_chalk43.default.yellow("Runtime only"));
+      console.log(import_chalk45.default.yellow("Runtime only"));
       for (const item of classifiedEntries.slice(0, DETAIL_LIMIT)) {
         const evidenceSuffix = item.nearestBacktestEntry ? ` nearestBacktestId=${item.nearestBacktestEntry.id} backtestDrift=${formatMinutes2(item.nearestBacktestEntryTimestampDiffMs ?? null)}` : item.evaluation ? ` replayEvaluationId=${item.evaluation.evaluationId} replayDrift=${formatMinutes2(item.evaluationTimestampDiffMs ?? null)} status=${item.evaluation.status}` : "";
         const price = item.entry.price == null ? "n/a" : item.entry.price.toFixed(6);
@@ -31058,17 +31893,17 @@ var init_reporting = __esm({
 var runtimeParity_exports = {};
 __export(runtimeParity_exports, {
   buildRuntimeParityMessage: () => buildRuntimeParityMessage,
-  main: () => main40,
+  main: () => main42,
   runtimeParity: () => runtimeParity
 });
-var import_config11, import_node_crypto14, import_args30, import_chalk44, import_constants15, import_time9, import_logger6, import_redis17, import_cli11, import_backtest3, import_connectors14, flags28, interval3, projectRoot13, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main40;
+var import_config11, import_node_crypto16, import_args32, import_chalk46, import_constants15, import_time9, import_logger6, import_redis17, import_cli11, import_backtest3, import_connectors14, flags30, interval3, projectRoot15, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main42;
 var init_runtimeParity2 = __esm({
   "src/scripts/runtimeParity.ts"() {
     "use strict";
     import_config11 = require("dotenv/config");
-    import_node_crypto14 = require("crypto");
-    import_args30 = __toESM(require("args"));
-    import_chalk44 = __toESM(require("chalk"));
+    import_node_crypto16 = require("crypto");
+    import_args32 = __toESM(require("args"));
+    import_chalk46 = __toESM(require("chalk"));
     import_constants15 = require("@tradejs/core/constants");
     import_time9 = require("@tradejs/core/time");
     import_logger6 = require("@tradejs/infra/logger");
@@ -31091,45 +31926,45 @@ var init_runtimeParity2 = __esm({
     init_reporting();
     init_reporting();
     init_runtimeModeConfig();
-    import_args30.default.option(["u", "user"], "Use user config", "root");
-    import_args30.default.option(
+    import_args32.default.option(["u", "user"], "Use user config", "root");
+    import_args32.default.option(
       ["o", "connector"],
       "Connector provider or name for parity replay (e.g. bybit, binance, coinbase, custom)",
       "bybit"
     );
-    import_args30.default.option(["d", "days"], "Replay window in days", 3);
-    import_args30.default.option(
+    import_args32.default.option(["d", "days"], "Replay window in days", 3);
+    import_args32.default.option(
       ["b", "startTime"],
       "Explicit replay start timestamp (ms or seconds)"
     );
-    import_args30.default.option(["e", "endTime"], "Explicit replay end timestamp (ms or seconds)");
-    import_args30.default.option(["s", "strategy"], "Only compare one strategy");
-    import_args30.default.option(
+    import_args32.default.option(["e", "endTime"], "Explicit replay end timestamp (ms or seconds)");
+    import_args32.default.option(["s", "strategy"], "Only compare one strategy");
+    import_args32.default.option(
       ["t", "tickers"],
       "Replay comma-separated symbols for all configured strategies"
     );
-    import_args30.default.option(
+    import_args32.default.option(
       ["C", "cacheOnly"],
       "Do not refresh market history before replay",
       false
     );
-    import_args30.default.option(
+    import_args32.default.option(
       ["a", "toleranceBars"],
       "Allowed entry timestamp drift in bars when matching runtime vs backtest",
       1
     );
-    import_args30.default.option(
+    import_args32.default.option(
       "fullUniverse",
       "Replay every configured strategy across the full connector universe. By default parity replays only runtime-traded and strategy-results symbols unless --tickers is provided.",
       false
     );
-    import_args30.default.option(
+    import_args32.default.option(
       "runtimeGates",
       "Force runtime AI/ML gates for all replay targets. Runtime-gated configs are replayed with gates by default.",
       false
     );
-    import_args30.default.option(["N", "notify"], "Send parity summary to Telegram", false);
-    import_args30.default.option(["D", "details"], "Print unmatched entry details (capped)", false);
+    import_args32.default.option(["N", "notify"], "Send parity summary to Telegram", false);
+    import_args32.default.option(["D", "details"], "Print unmatched entry details (capped)", false);
     process.argv = normalizeCliArgv(process.argv, {
       "-C": "--cacheOnly",
       "-D": "--details",
@@ -31138,14 +31973,14 @@ var init_runtimeParity2 = __esm({
       "-S": "--startTime",
       "-T": "--toleranceBars"
     });
-    flags28 = import_args30.default.parse(process.argv);
+    flags30 = import_args32.default.parse(process.argv);
     interval3 = "15";
-    projectRoot13 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    projectRoot15 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     DEFAULT_LOOKBACK_DAYS = 3;
     DETAIL_LIMIT2 = 10;
-    DEFAULT_REPLAY_ENV = flags28.runtimeGates ? "PARITY" : "BACKTEST";
+    DEFAULT_REPLAY_ENV = flags30.runtimeGates ? "PARITY" : "BACKTEST";
     resolveParityConnectorName = async (value) => {
-      const connectorName = await (0, import_connectors14.resolveConnectorName)(value, projectRoot13);
+      const connectorName = await (0, import_connectors14.resolveConnectorName)(value, projectRoot15);
       if (connectorName) {
         return connectorName;
       }
@@ -31162,7 +31997,7 @@ var init_runtimeParity2 = __esm({
     }) => {
       const connectorFactory = await (0, import_connectors14.getConnectorCreatorByName)(
         connectorName,
-        projectRoot13
+        projectRoot15
       );
       if (!connectorFactory) {
         throw new Error(`Connector "${connectorName}" is not registered`);
@@ -31254,7 +32089,7 @@ var init_runtimeParity2 = __esm({
         strategyConfig,
         env: resolveReplayStrategyEnv({
           strategyConfig,
-          forceRuntimeGates: Boolean(flags28.runtimeGates)
+          forceRuntimeGates: Boolean(flags30.runtimeGates)
         }),
         interval: interval3,
         makeOrders: true,
@@ -31273,7 +32108,7 @@ var init_runtimeParity2 = __esm({
       const symbols = [...new Set(targets.map((target) => target.symbol))];
       const warmStartedAt = Date.now();
       console.log(
-        import_chalk44.default.gray(
+        import_chalk46.default.gray(
           `Warm history: ${symbols.length} symbol(s) on ${connectorName}, preload ${(0, import_time9.formatUnix)(preloadStart)} -> ${(0, import_time9.formatUnix)(preloadEnd)}`
         )
       );
@@ -31281,7 +32116,7 @@ var init_runtimeParity2 = __esm({
         connectorName,
         marketConnector: connector,
         userName: userName3,
-        projectRoot: projectRoot13,
+        projectRoot: projectRoot15,
         shouldUseDedicatedReferences: true,
         warn: (message) => import_logger6.logger.warn(message)
       });
@@ -31293,39 +32128,39 @@ var init_runtimeParity2 = __esm({
         symbols,
         preloadStart,
         preloadEnd,
-        log: (message) => console.log(import_chalk44.default.gray(message))
+        log: (message) => console.log(import_chalk46.default.gray(message))
       });
       console.log(
-        import_chalk44.default.gray(`Warm history: done in ${formatDuration(warmStartedAt)}`)
+        import_chalk46.default.gray(`Warm history: done in ${formatDuration(warmStartedAt)}`)
       );
     };
     runtimeParity = async () => {
       const window = resolveTimeWindow({
-        days: flags28.days ?? DEFAULT_LOOKBACK_DAYS,
-        startTime: flags28.startTime,
-        endTime: flags28.endTime,
+        days: flags30.days ?? DEFAULT_LOOKBACK_DAYS,
+        startTime: flags30.startTime,
+        endTime: flags30.endTime,
         defaultStartMs: Date.now() - DEFAULT_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3,
         defaultEndMs: Date.now()
       });
       const toleranceBars = Math.max(
         0,
-        Number.parseInt(String(flags28.toleranceBars ?? 1), 10) || 0
+        Number.parseInt(String(flags30.toleranceBars ?? 1), 10) || 0
       );
       const toleranceMs = toleranceBars * 15 * 60 * 1e3;
-      const connectorName = await resolveParityConnectorName(flags28.connector);
-      const requestedSymbols = parseSymbolsFromCLI2(String(flags28.tickers || ""));
+      const connectorName = await resolveParityConnectorName(flags30.connector);
+      const requestedSymbols = parseSymbolsFromCLI2(String(flags30.tickers || ""));
       const requestedSymbolSet = requestedSymbols.length ? new Set(requestedSymbols) : null;
       let replayErrors = [];
       try {
         const parityConnector = await createConnector({
-          userName: flags28.user,
+          userName: flags30.user,
           connectorName
         });
         const { runtimeTrades, runtimeSignals, runtimeSignalEvaluations } = await loadRuntimeParityEvidence(
           {
-            userName: flags28.user,
+            userName: flags30.user,
             window,
-            strategy: flags28.strategy,
+            strategy: flags30.strategy,
             symbols: requestedSymbolSet
           },
           {
@@ -31340,29 +32175,29 @@ var init_runtimeParity2 = __esm({
           runtimeSignalEvaluations
         });
         const replayTargets = await buildReplayTargets({
-          userName: flags28.user,
+          userName: flags30.user,
           runtimeTrades,
           connectorSymbols,
-          strategyFilter: String(flags28.strategy || "").trim() || void 0,
+          strategyFilter: String(flags30.strategy || "").trim() || void 0,
           explicitSymbols: requestedSymbols,
-          includeConnectorUniverse: Boolean(flags28.fullUniverse)
+          includeConnectorUniverse: Boolean(flags30.fullUniverse)
         });
         if (!replayTargets.length) {
           console.log(
-            import_chalk44.default.yellow(
-              `No replay targets found for ${flags28.user} in ${(0, import_time9.formatUnix)(window.start)} -> ${(0, import_time9.formatUnix)(window.end)}.`
+            import_chalk46.default.yellow(
+              `No replay targets found for ${flags30.user} in ${(0, import_time9.formatUnix)(window.start)} -> ${(0, import_time9.formatUnix)(window.end)}.`
             )
           );
-          if (flags28.notify) {
+          if (flags30.notify) {
             await sendTelegramReport(
               buildRuntimeParityNoTargetsMessage({
                 window,
                 connectorName,
                 replayEnv: DEFAULT_REPLAY_ENV,
-                runtimeGatesEnabled: Boolean(flags28.runtimeGates),
-                userName: String(flags28.user)
+                runtimeGatesEnabled: Boolean(flags30.runtimeGates),
+                userName: String(flags30.user)
               }),
-              { userName: flags28.user }
+              { userName: flags30.user }
             );
           }
           return;
@@ -31377,14 +32212,14 @@ var init_runtimeParity2 = __esm({
           replayTargets.map((target) => target.symbol)
         ).size;
         console.log(
-          import_chalk44.default.gray(
-            `Replay queue: ${replayTargets.length} target(s), ${replaySymbolsCount} symbol(s), mode=${flags28.fullUniverse ? "full-universe" : requestedSymbols.length ? "explicit-tickers" : "runtime+results"}`
+          import_chalk46.default.gray(
+            `Replay queue: ${replayTargets.length} target(s), ${replaySymbolsCount} symbol(s), mode=${flags30.fullUniverse ? "full-universe" : requestedSymbols.length ? "explicit-tickers" : "runtime+results"}`
           )
         );
         const replayConfigs = /* @__PURE__ */ new Map();
         for (const target of replayTargets) {
           const replayConfig = await buildReplayConfig({
-            userName: flags28.user,
+            userName: flags30.user,
             strategy: target.strategy,
             symbol: target.symbol,
             replayInputsIndex,
@@ -31401,22 +32236,22 @@ var init_runtimeParity2 = __esm({
         );
         await prepareMarketContextForRun({
           mode: "parity",
-          userName: flags28.user,
-          projectRoot: projectRoot13,
+          userName: flags30.user,
+          projectRoot: projectRoot15,
           symbols: replayTargets.map((target) => target.symbol),
           interval: interval3,
           startMs: window.start,
           endMs: window.end,
           preloadStartMs: preloadStart,
-          cacheOnly: Boolean(flags28.cacheOnly),
+          cacheOnly: Boolean(flags30.cacheOnly),
           aiEnabled: hasParityAiTargets,
           mlEnabled: hasParityMlTargets,
           strategyNames: replayTargets.map((target) => target.strategy),
-          log: (message) => console.log(import_chalk44.default.gray(message))
+          log: (message) => console.log(import_chalk46.default.gray(message))
         });
-        if (!flags28.cacheOnly) {
+        if (!flags30.cacheOnly) {
           await warmReplayHistory({
-            userName: flags28.user,
+            userName: flags30.user,
             connectorName,
             targets: replayTargets,
             preloadStart,
@@ -31443,15 +32278,15 @@ var init_runtimeParity2 = __esm({
               );
             }
             const result = await (0, import_backtest3.testing)({
-              userName: flags28.user,
+              userName: flags30.user,
               symbol: target.symbol,
               options: {
                 start: window.start,
                 end: window.end
               },
-              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto14.randomUUID)().slice(0, 8)}`,
-              testId: (0, import_node_crypto14.randomUUID)().slice(0, 8),
-              testSuiteId: (0, import_node_crypto14.randomUUID)().slice(0, 8),
+              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto16.randomUUID)().slice(0, 8)}`,
+              testId: (0, import_node_crypto16.randomUUID)().slice(0, 8),
+              testSuiteId: (0, import_node_crypto16.randomUUID)().slice(0, 8),
               strategyName: target.strategy,
               strategyConfig: replayConfig,
               connectorName,
@@ -31472,15 +32307,15 @@ var init_runtimeParity2 = __esm({
             });
           } finally {
             (0, import_backtest3.releaseTestingSymbolCache)({
-              cwd: projectRoot13,
-              userName: flags28.user,
+              cwd: projectRoot15,
+              userName: flags30.user,
               connectorName,
               symbol: target.symbol
             });
           }
           if (progressPosition === 1 || progressPosition === replayTargets.length || progressPosition % 25 === 0) {
             console.log(
-              import_chalk44.default.gray(
+              import_chalk46.default.gray(
                 `Replay progress: ${progressPosition}/${replayTargets.length}, ok=${successfulTargetKeys.size}, errors=${replayErrors.length}, current=${target.strategy} ${target.symbol}, elapsed=${formatDuration(replayStartedAt)}`
               )
             );
@@ -31511,8 +32346,8 @@ var init_runtimeParity2 = __esm({
             window,
             connectorName,
             replayEnv: replayEnvSummary,
-            runtimeGatesEnabled: Boolean(flags28.runtimeGates) || replayEnvSummary.includes("PARITY"),
-            runtimeGatesRequested: Boolean(flags28.runtimeGates),
+            runtimeGatesEnabled: Boolean(flags30.runtimeGates) || replayEnvSummary.includes("PARITY"),
+            runtimeGatesRequested: Boolean(flags30.runtimeGates),
             toleranceBars,
             toleranceMs,
             replayTargetsCount: replayTargets.length,
@@ -31535,12 +32370,12 @@ var init_runtimeParity2 = __esm({
             detailLimit: DETAIL_LIMIT2
           })
         );
-        if (flags28.details) {
+        if (flags30.details) {
           printRuntimeDuplicateDetails(runtimeDedupe.duplicateGroups);
           printClassifiedRuntimeOnlyDetails(classifiedRuntimeOnly);
           printClassifiedBacktestOnlyDetails(classifiedBacktestOnly);
         }
-        if (flags28.notify) {
+        if (flags30.notify) {
           const mismatchAttachment = buildRuntimeParityMismatchAttachment({
             window,
             connectorName,
@@ -31569,7 +32404,7 @@ var init_runtimeParity2 = __esm({
               window,
               connectorName,
               replayEnv: replayEnvSummary,
-              runtimeGatesEnabled: Boolean(flags28.runtimeGates) || replayEnvSummary.includes("PARITY"),
+              runtimeGatesEnabled: Boolean(flags30.runtimeGates) || replayEnvSummary.includes("PARITY"),
               toleranceBars,
               toleranceMs,
               replayTargetsCount: replayTargets.length,
@@ -31591,16 +32426,16 @@ var init_runtimeParity2 = __esm({
               runtimeGateWarningCounts
             }),
             {
-              userName: flags28.user,
+              userName: flags30.user,
               attachments: mismatchAttachment ? [mismatchAttachment] : void 0
             }
           );
         }
       } finally {
-        (0, import_backtest3.resetTestingKlineCache)(projectRoot13);
+        (0, import_backtest3.resetTestingKlineCache)(projectRoot15);
       }
     };
-    main40 = runtimeParity;
+    main42 = runtimeParity;
   }
 });
 
@@ -31679,11 +32514,11 @@ var init_runtimeStrategies = __esm({
 });
 
 // src/lib/signals/skipStats.ts
-var import_chalk45, import_logger7, createStrategySkipStats, recordStrategyReason, logStrategySkipStats;
+var import_chalk47, import_logger7, createStrategySkipStats, recordStrategyReason, logStrategySkipStats;
 var init_skipStats = __esm({
   "src/lib/signals/skipStats.ts"() {
     "use strict";
-    import_chalk45 = __toESM(require("chalk"));
+    import_chalk47 = __toESM(require("chalk"));
     import_logger7 = require("@tradejs/infra/logger");
     init_runtimeSignalsStorage();
     createStrategySkipStats = (runtimeStrategies) => new Map(
@@ -31709,7 +32544,7 @@ var init_skipStats = __esm({
       );
     };
     logStrategySkipStats = (runtimeStrategies, strategyStats) => {
-      import_logger7.logger.info(import_chalk45.default.yellow("skip stats:"));
+      import_logger7.logger.info(import_chalk47.default.yellow("skip stats:"));
       for (const { strategyName } of runtimeStrategies) {
         const stats = strategyStats.get(strategyName);
         if (!stats) {
@@ -32654,12 +33489,12 @@ var init_configuredScopes = __esm({
 });
 
 // src/lib/signals/runner.ts
-var import_progress11, import_chalk46, import_connectors16, import_cli12, import_async5, import_strategies11, import_constants16, import_time10, import_logger10, import_runtimeHeartbeats, import_runtimeStrategies6, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
+var import_progress11, import_chalk48, import_connectors16, import_cli12, import_async5, import_strategies11, import_constants16, import_time10, import_logger10, import_runtimeHeartbeats, import_runtimeStrategies6, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
 var init_runner = __esm({
   "src/lib/signals/runner.ts"() {
     "use strict";
     import_progress11 = __toESM(require("progress"));
-    import_chalk46 = __toESM(require("chalk"));
+    import_chalk48 = __toESM(require("chalk"));
     import_connectors16 = require("@tradejs/node/connectors");
     import_cli12 = require("@tradejs/node/cli");
     import_async5 = require("@tradejs/core/async");
@@ -32703,7 +33538,7 @@ var init_runner = __esm({
     };
     createSignalsRunner = (config2) => {
       const interval4 = config2.interval;
-      const projectRoot15 = config2.projectRoot?.trim() || String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+      const projectRoot17 = config2.projectRoot?.trim() || String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
       const resolveSignalsDaemonMaxLiveBars = (runtimeInterval = interval4) => {
         const intervalMinutes = Number(runtimeInterval);
         const preloadBars = Math.ceil(
@@ -32726,7 +33561,7 @@ var init_runner = __esm({
       const timeOperation3 = (label, operation) => timeOperation(
         label,
         operation,
-        (message) => import_logger10.logger.info(import_chalk46.default.gray(message))
+        (message) => import_logger10.logger.info(import_chalk48.default.gray(message))
       );
       const formatSlowSignalsWarning = (params) => [
         "<b>Slow yarn signals run</b>",
@@ -32736,7 +33571,7 @@ var init_runner = __esm({
         `Found signals: <b>${params.found}</b>`
       ].join("\n");
       const resolveSignalsConnectorName = async (value) => {
-        const connectorName = await (0, import_connectors16.resolveConnectorName)(value, projectRoot15);
+        const connectorName = await (0, import_connectors16.resolveConnectorName)(value, projectRoot17);
         if (!connectorName) {
           throw new Error(
             `Unknown runtime connector: ${String(value || "").trim() || String(value)}`
@@ -32747,7 +33582,7 @@ var init_runner = __esm({
       const createSignalsSession2 = async (lifecycle, scope = {}) => {
         const deployment = config2.deploymentId ? await (0, import_runtimeStrategies6.getRuntimeDeployment)({
           userName: config2.userName,
-          projectRoot: projectRoot15,
+          projectRoot: projectRoot17,
           deploymentId: config2.deploymentId
         }) : null;
         if (config2.deploymentId && !deployment) {
@@ -32766,7 +33601,7 @@ var init_runner = __esm({
         const requestedAccountId = deployment?.accountId ?? scope.accountId ?? config2.accountId;
         const connectorFactory = await (0, import_connectors16.getConnectorCreatorByName)(
           connectorName,
-          projectRoot15
+          projectRoot17
         );
         if (!connectorFactory) {
           throw new Error(`Connector "${connectorName}" is not registered`);
@@ -32781,7 +33616,7 @@ var init_runner = __esm({
           connectorName,
           marketConnector,
           userName: config2.userName,
-          projectRoot: projectRoot15,
+          projectRoot: projectRoot17,
           shouldUseDedicatedReferences: universe === "crypto" && connectorName.toLowerCase() === import_connectors16.DEFAULT_CONNECTOR_NAME.toLowerCase(),
           warn: (message) => import_logger10.logger.warn(message)
         });
@@ -32841,7 +33676,7 @@ var init_runner = __esm({
           const selectedTickers = selection?.tickers ? [.../* @__PURE__ */ new Set([...selection.tickers, ...selectedActiveSymbols])] : void 0;
           if (selectedActiveSymbols.length) {
             import_logger10.logger.info(
-              import_chalk46.default.gray(
+              import_chalk48.default.gray(
                 `strategy selection retained active symbols: ${selectedActiveSymbols.join(", ")}`
               )
             );
@@ -32871,10 +33706,10 @@ var init_runner = __esm({
             instruments.map((instrument) => [instrument.symbol, instrument])
           );
           if (config2.showTickersList) {
-            console.log(import_chalk46.default.gray(JSON.stringify(tickers.sort(), null, 2)));
+            console.log(import_chalk48.default.gray(JSON.stringify(tickers.sort(), null, 2)));
             return;
           }
-          const projectConfig = await (0, import_cli12.loadTradejsConfig)(projectRoot15);
+          const projectConfig = await (0, import_cli12.loadTradejsConfig)(projectRoot17);
           projectHooks = projectConfig.hooks;
           const currentTimestamp = (0, import_time10.getTimestamp)();
           const preloadStart = (0, import_time10.getTimestamp)(import_constants16.SIGNALS_CLI_PRELOAD_DAYS);
@@ -32892,7 +33727,7 @@ var init_runner = __esm({
             );
             await session.klineFeed.flush();
             import_logger10.logger.info(
-              import_chalk46.default.gray(
+              import_chalk48.default.gray(
                 `websocket candles: ready=${expectedSymbols.length - missingSymbols.length}/${expectedSymbols.length} missing=${missingSymbols.length}`
               )
             );
@@ -32903,7 +33738,7 @@ var init_runner = __esm({
               symbols: missingSymbols,
               preloadDays: import_constants16.SIGNALS_CLI_PRELOAD_DAYS,
               universe,
-              log: (message) => import_logger10.logger.info(import_chalk46.default.gray(message))
+              log: (message) => import_logger10.logger.info(import_chalk48.default.gray(message))
             });
             await updateBtcReferenceHistory({
               marketConnector,
@@ -32911,7 +33746,7 @@ var init_runner = __esm({
               interval: interval5,
               preloadDays: import_constants16.SIGNALS_CLI_PRELOAD_DAYS,
               universe,
-              log: (message) => import_logger10.logger.info(import_chalk46.default.gray(message))
+              log: (message) => import_logger10.logger.info(import_chalk48.default.gray(message))
             });
           } else if (!config2.cacheOnly) {
             await updateMarketHistoryWithBtcReferences({
@@ -32922,13 +33757,13 @@ var init_runner = __esm({
               symbols: tickers,
               preloadDays: import_constants16.SIGNALS_CLI_PRELOAD_DAYS,
               universe,
-              log: (message) => import_logger10.logger.info(import_chalk46.default.gray(message))
+              log: (message) => import_logger10.logger.info(import_chalk48.default.gray(message))
             });
           }
           await prepareMarketContextForRun({
             mode: "signals",
             userName: config2.userName,
-            projectRoot: projectRoot15,
+            projectRoot: projectRoot17,
             symbols: tickers,
             universe,
             interval: interval5,
@@ -32936,7 +33771,7 @@ var init_runner = __esm({
             endMs: currentTimestamp,
             preloadStartMs: preloadStart,
             cacheOnly: config2.cacheOnly,
-            log: (message) => import_logger10.logger.info(import_chalk46.default.gray(message))
+            log: (message) => import_logger10.logger.info(import_chalk48.default.gray(message))
           });
           if (config2.updateOnly) {
             return;
@@ -32994,7 +33829,7 @@ var init_runner = __esm({
           );
           const configuredRuntimeStrategies = await (0, import_runtimeStrategies5.loadResolvedRuntimeStrategies)({
             userName: config2.userName,
-            projectRoot: projectRoot15,
+            projectRoot: projectRoot17,
             deploymentId: deployment?.id ?? "",
             universe,
             accountId,
@@ -33031,7 +33866,7 @@ var init_runner = __esm({
             )
           );
           import_logger10.logger.info(
-            import_chalk46.default.yellow(
+            import_chalk48.default.yellow(
               `loaded strategies (user=${config2.userName}): ${runtimeStrategies.map(formatConfiguredStrategyIdentity).join(", ")}`
             )
           );
@@ -33067,9 +33902,9 @@ var init_runner = __esm({
               width: 30
             }
           );
-          import_logger10.logger.info(import_chalk46.default.yellow(`tickers: ${tickers.length}`));
+          import_logger10.logger.info(import_chalk48.default.yellow(`tickers: ${tickers.length}`));
           const signalsParallel = resolvePositiveInteger2(config2.parallel, 4);
-          import_logger10.logger.info(import_chalk46.default.yellow(`signal workers: ${signalsParallel}`));
+          import_logger10.logger.info(import_chalk48.default.yellow(`signal workers: ${signalsParallel}`));
           const evaluateTicker = createSignalsTickerEvaluator({
             userName: config2.userName,
             makeOrders: config2.makeOrders,
@@ -33108,8 +33943,8 @@ var init_runner = __esm({
                 signals3.push(...strategySignals);
               }
               bar.tick(1, {
-                found: import_chalk46.default.cyan(signals3.length),
-                symbol: import_chalk46.default.gray(symbol)
+                found: import_chalk48.default.cyan(signals3.length),
+                symbol: import_chalk48.default.gray(symbol)
               });
             });
           });
@@ -33213,7 +34048,7 @@ var init_runner = __esm({
             }
           }
           import_logger10.logger.info(
-            import_chalk46.default.yellow(
+            import_chalk48.default.yellow(
               `signals ${status} in ${formatDuration3(durationMs)} (found=${signals3.length})`
             )
           );
@@ -33225,7 +34060,7 @@ var init_runner = __esm({
       const loadConfiguredSignalsScopes = async (deployment) => {
         const configuredStrategies = await (0, import_runtimeStrategies5.loadResolvedRuntimeStrategies)({
           userName: config2.userName,
-          projectRoot: projectRoot15,
+          projectRoot: projectRoot17,
           deploymentId: deployment.id
         });
         const connectorName = await resolveSignalsConnectorName(
@@ -33248,7 +34083,7 @@ var init_runner = __esm({
         }
         const configuredDeployment = await (0, import_runtimeStrategies6.getRuntimeDeployment)({
           userName: config2.userName,
-          projectRoot: projectRoot15,
+          projectRoot: projectRoot17,
           deploymentId: config2.deploymentId
         });
         if (!configuredDeployment) {
@@ -33282,7 +34117,7 @@ var init_runner = __esm({
         const deploymentId = config2.deploymentId;
         const initialDeployment = await (0, import_runtimeStrategies6.getRuntimeDeployment)({
           userName: config2.userName,
-          projectRoot: projectRoot15,
+          projectRoot: projectRoot17,
           deploymentId
         });
         if (!initialDeployment) {
@@ -33307,7 +34142,7 @@ var init_runner = __esm({
             runCycle: async () => {
               const currentDeployment = await (0, import_runtimeStrategies6.getRuntimeDeployment)({
                 userName: config2.userName,
-                projectRoot: projectRoot15,
+                projectRoot: projectRoot17,
                 deploymentId
               });
               if (!currentDeployment) {
@@ -33414,107 +34249,107 @@ var init_runner = __esm({
 var signals_exports = {};
 __export(signals_exports, {
   createSignalsSession: () => createSignalsSession,
-  main: () => main41,
+  main: () => main43,
   signals: () => signals,
   signalsConfiguredScopesOnce: () => signalsConfiguredScopesOnce,
   signalsDaemon: () => signalsDaemon
 });
-var import_config12, import_args31, flags29, config, runner, createSignalsSession, signals, signalsConfiguredScopesOnce, signalsDaemon, main41;
+var import_config12, import_args33, flags31, config, runner, createSignalsSession, signals, signalsConfiguredScopesOnce, signalsDaemon, main43;
 var init_signals = __esm({
   "src/scripts/signals.ts"() {
     "use strict";
     import_config12 = require("dotenv/config");
-    import_args31 = __toESM(require("args"));
+    import_args33 = __toESM(require("args"));
     init_runner();
-    import_args31.default.option(["t", "tickers"], "Selected tickers");
-    import_args31.default.option(["e", "exclude"], "Exclude tickers from tests");
-    import_args31.default.option(["l", "tickersLimit"], "Tickers limit");
-    import_args31.default.option(["f", "timeframe"], "Timeframe", 15);
-    import_args31.default.option(["m", "makeOrders"], "Make orders");
-    import_args31.default.option(["N", "notify"], "Send message in Telegram", false);
-    import_args31.default.option(["S", "skipScreenshots"], "Skip screenshot generation", false);
-    import_args31.default.option(["u", "updateOnly"], "Only update tickers history", false);
-    import_args31.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
-    import_args31.default.option(["L", "showTickersList"], "Just show only ticker list", false);
-    import_args31.default.option(
+    import_args33.default.option(["t", "tickers"], "Selected tickers");
+    import_args33.default.option(["e", "exclude"], "Exclude tickers from tests");
+    import_args33.default.option(["l", "tickersLimit"], "Tickers limit");
+    import_args33.default.option(["f", "timeframe"], "Timeframe", 15);
+    import_args33.default.option(["m", "makeOrders"], "Make orders");
+    import_args33.default.option(["N", "notify"], "Send message in Telegram", false);
+    import_args33.default.option(["S", "skipScreenshots"], "Skip screenshot generation", false);
+    import_args33.default.option(["u", "updateOnly"], "Only update tickers history", false);
+    import_args33.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
+    import_args33.default.option(["L", "showTickersList"], "Just show only ticker list", false);
+    import_args33.default.option(
       ["p", "parallel"],
       "Signal evaluation worker count",
       Number(process.env.SIGNALS_PARALLEL || 4)
     );
-    import_args31.default.option(
+    import_args33.default.option(
       ["R", "showSkipStats"],
       "Show aggregated skip stats by strategy",
       false
     );
-    import_args31.default.option(["c", "chunk"], "Split by chunks, ex. 1/3");
-    import_args31.default.option(["U", "user"], "Use user confg", "root");
-    import_args31.default.option(["w", "watch"], "Keep signals running on candle boundaries", false);
-    import_args31.default.option(
+    import_args33.default.option(["c", "chunk"], "Split by chunks, ex. 1/3");
+    import_args33.default.option(["U", "user"], "Use user confg", "root");
+    import_args33.default.option(["w", "watch"], "Keep signals running on candle boundaries", false);
+    import_args33.default.option(
       ["d", "settleDelayMs"],
       "Delay after candle close before a daemon cycle",
       Number(process.env.SIGNALS_DAEMON_SETTLE_DELAY_MS || 5e3)
     );
-    import_args31.default.option(
+    import_args33.default.option(
       ["o", "connector"],
       "Connector provider or name for signals (e.g. bybit, binance, coinbase, custom)",
       "bybit"
     );
-    import_args31.default.option(["V", "universe"], "Market universe (crypto or tradfi)", "crypto");
-    import_args31.default.option(["A", "account"], "Trading account id");
-    import_args31.default.option(["D", "deployment"], "Runtime deployment id");
-    flags29 = import_args31.default.parse(process.argv);
+    import_args33.default.option(["V", "universe"], "Market universe (crypto or tradfi)", "crypto");
+    import_args33.default.option(["A", "account"], "Trading account id");
+    import_args33.default.option(["D", "deployment"], "Runtime deployment id");
+    flags31 = import_args33.default.parse(process.argv);
     config = {
       projectRoot: String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd(),
-      userName: String(flags29.user || "root"),
-      interval: String(flags29.timeframe ?? 15),
-      connectorName: String(flags29.connector || "bybit"),
-      universe: flags29.universe,
-      accountId: flags29.account ? String(flags29.account) : void 0,
-      deploymentId: flags29.deployment ? String(flags29.deployment) : void 0,
-      tickers: flags29.tickers,
-      exclude: flags29.exclude,
-      tickersLimit: flags29.tickersLimit,
-      chunk: flags29.chunk,
-      makeOrders: Boolean(flags29.makeOrders),
-      notify: Boolean(flags29.notify),
-      skipScreenshots: Boolean(flags29.skipScreenshots),
-      updateOnly: Boolean(flags29.updateOnly),
-      cacheOnly: Boolean(flags29.cacheOnly),
-      showTickersList: Boolean(flags29.showTickersList),
-      showSkipStats: Boolean(flags29.showSkipStats),
-      parallel: flags29.parallel,
-      watch: Boolean(flags29.watch),
-      settleDelayMs: flags29.settleDelayMs
+      userName: String(flags31.user || "root"),
+      interval: String(flags31.timeframe ?? 15),
+      connectorName: String(flags31.connector || "bybit"),
+      universe: flags31.universe,
+      accountId: flags31.account ? String(flags31.account) : void 0,
+      deploymentId: flags31.deployment ? String(flags31.deployment) : void 0,
+      tickers: flags31.tickers,
+      exclude: flags31.exclude,
+      tickersLimit: flags31.tickersLimit,
+      chunk: flags31.chunk,
+      makeOrders: Boolean(flags31.makeOrders),
+      notify: Boolean(flags31.notify),
+      skipScreenshots: Boolean(flags31.skipScreenshots),
+      updateOnly: Boolean(flags31.updateOnly),
+      cacheOnly: Boolean(flags31.cacheOnly),
+      showTickersList: Boolean(flags31.showTickersList),
+      showSkipStats: Boolean(flags31.showSkipStats),
+      parallel: flags31.parallel,
+      watch: Boolean(flags31.watch),
+      settleDelayMs: flags31.settleDelayMs
     };
     runner = createSignalsRunner(config);
     createSignalsSession = runner.createSession;
     signals = runner.runCycle;
     signalsConfiguredScopesOnce = runner.runConfiguredScopesOnce;
     signalsDaemon = runner.runDaemon;
-    main41 = () => config.watch ? signalsDaemon() : signalsConfiguredScopesOnce();
+    main43 = () => config.watch ? signalsDaemon() : signalsConfiguredScopesOnce();
   }
 });
 
 // src/scripts/signalsDaemon.ts
 var signalsDaemon_exports = {};
 __export(signalsDaemon_exports, {
-  main: () => main42
+  main: () => main44
 });
-var main42;
+var main44;
 var init_signalsDaemon = __esm({
   "src/scripts/signalsDaemon.ts"() {
     "use strict";
     init_signals();
-    main42 = signalsDaemon;
+    main44 = signalsDaemon;
   }
 });
 
 // src/lib/replay/cliConfig.ts
-var import_args32, REPLAY_UNSUPPORTED_FLAGS, hasCliFlag2, assertNoUnsupportedReplayFlags, replayNormalizedArgv, replayFlags, replayInterval, replayUserName, replayProjectRoot, replayRuntimeEvidencePath, replayDeploymentId, isReplayUpdateOnlyRun;
+var import_args34, REPLAY_UNSUPPORTED_FLAGS, hasCliFlag2, assertNoUnsupportedReplayFlags, replayNormalizedArgv, replayFlags, replayInterval, replayUserName, replayProjectRoot, replayRuntimeEvidencePath, replayDeploymentId, isReplayUpdateOnlyRun;
 var init_cliConfig2 = __esm({
   "src/lib/replay/cliConfig.ts"() {
     "use strict";
-    import_args32 = __toESM(require("args"));
+    import_args34 = __toESM(require("args"));
     init_cliArgs();
     REPLAY_UNSUPPORTED_FLAGS = [
       ["--live", "`yarn replay` is already the replacement for legacy `--live`."],
@@ -33548,36 +34383,36 @@ var init_cliConfig2 = __esm({
         }
       }
     };
-    import_args32.default.example(
+    import_args34.default.example(
       "yarn replay --days 7 --cacheOnly",
       "Replay active runtime strategies on historical data"
     );
-    import_args32.default.option(["t", "tickers"], "Selected tickers");
-    import_args32.default.option(["e", "exclude"], "Exclude tickers from replay");
-    import_args32.default.option(["l", "tickersLimit"], "Tickers limit");
-    import_args32.default.option(["f", "timeframe"], "Timeframe", 15);
-    import_args32.default.option(["d", "days"], "Run replay only for the last N days");
-    import_args32.default.option("startTime", "Explicit replay start timestamp (ms or seconds)");
-    import_args32.default.option("endTime", "Explicit replay end timestamp (ms or seconds)");
-    import_args32.default.option(
+    import_args34.default.option(["t", "tickers"], "Selected tickers");
+    import_args34.default.option(["e", "exclude"], "Exclude tickers from replay");
+    import_args34.default.option(["l", "tickersLimit"], "Tickers limit");
+    import_args34.default.option(["f", "timeframe"], "Timeframe", 15);
+    import_args34.default.option(["d", "days"], "Run replay only for the last N days");
+    import_args34.default.option("startTime", "Explicit replay start timestamp (ms or seconds)");
+    import_args34.default.option("endTime", "Explicit replay end timestamp (ms or seconds)");
+    import_args34.default.option(
       "runtimeEvidence",
       "Immutable runtime evidence JSON used for offline runtime comparison"
     );
-    import_args32.default.option(
+    import_args34.default.option(
       "deployment",
       "Git-owned runtime deployment used when runtime evidence is omitted",
       "production"
     );
-    import_args32.default.option(["u", "updateOnly"], "Only update tickers history", false);
-    import_args32.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
-    import_args32.default.option(
+    import_args34.default.option(["u", "updateOnly"], "Only update tickers history", false);
+    import_args34.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
+    import_args34.default.option(
       "chart",
       "Save compact replay chart data for the strategies UI",
       false
     );
-    import_args32.default.option(["L", "showTickersList"], "Just show only ticker list", false);
-    import_args32.default.option(["U", "user"], "Use user config", "root");
-    import_args32.default.option(
+    import_args34.default.option(["L", "showTickersList"], "Just show only ticker list", false);
+    import_args34.default.option(["U", "user"], "Use user config", "root");
+    import_args34.default.option(
       ["o", "connector"],
       "Connector provider or name for replay (e.g. bybit, binance, coinbase, custom)",
       "bybit"
@@ -33589,7 +34424,7 @@ var init_cliConfig2 = __esm({
       "-U": "--user"
     });
     assertNoUnsupportedReplayFlags(replayNormalizedArgv);
-    replayFlags = import_args32.default.parse(replayNormalizedArgv);
+    replayFlags = import_args34.default.parse(replayNormalizedArgv);
     replayInterval = String(replayFlags.timeframe ?? 15);
     replayUserName = String(replayFlags.user ?? "root");
     replayProjectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
@@ -33602,12 +34437,12 @@ var init_cliConfig2 = __esm({
 });
 
 // src/lib/replay/runtimeEvidenceSource.ts
-var import_promises28, import_node_path23, asRecord7, asFiniteNumber, unwrapRows2, assertRuntimeRowsMatchDeployment, readRuntimeEvidenceArtifact, loadReplayRuntimeEvidenceMetadata, buildRuntimeEvidenceLineageScopes, loadReplayRuntimeEvidenceSource;
+var import_promises32, import_node_path29, asRecord7, asFiniteNumber, unwrapRows2, assertRuntimeRowsMatchDeployment, readRuntimeEvidenceArtifact, loadReplayRuntimeEvidenceMetadata, buildRuntimeEvidenceLineageScopes, loadReplayRuntimeEvidenceSource;
 var init_runtimeEvidenceSource = __esm({
   "src/lib/replay/runtimeEvidenceSource.ts"() {
     "use strict";
-    import_promises28 = __toESM(require("fs/promises"));
-    import_node_path23 = __toESM(require("path"));
+    import_promises32 = __toESM(require("fs/promises"));
+    import_node_path29 = __toESM(require("path"));
     init_runtimeLineage();
     init_runtimeEvidenceDeployment();
     asRecord7 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -33636,11 +34471,11 @@ var init_runtimeEvidenceSource = __esm({
     };
     readRuntimeEvidenceArtifact = async ({
       filePath,
-      projectRoot: projectRoot15
+      projectRoot: projectRoot17
     }) => {
-      const resolvedPath = import_node_path23.default.resolve(projectRoot15, filePath);
+      const resolvedPath = import_node_path29.default.resolve(projectRoot17, filePath);
       const root = asRecord7(
-        JSON.parse(await import_promises28.default.readFile(resolvedPath, "utf8"))
+        JSON.parse(await import_promises32.default.readFile(resolvedPath, "utf8"))
       );
       const runtime = asRecord7(root?.runtime) ?? root;
       if (!root || !runtime) {
@@ -33737,11 +34572,11 @@ var init_runtimeEvidenceSource = __esm({
     };
     loadReplayRuntimeEvidenceSource = async ({
       filePath,
-      projectRoot: projectRoot15,
+      projectRoot: projectRoot17,
       expectedUserName,
       expectedWindow
     }) => {
-      const { resolvedPath, runtime, userName: userName3, startTime, endTime, deployment } = await readRuntimeEvidenceArtifact({ filePath, projectRoot: projectRoot15 });
+      const { resolvedPath, runtime, userName: userName3, startTime, endTime, deployment } = await readRuntimeEvidenceArtifact({ filePath, projectRoot: projectRoot17 });
       if (!userName3 || userName3 !== expectedUserName) {
         throw new Error(
           `Runtime evidence user mismatch: expected=${expectedUserName}, actual=${userName3 || "missing"}`
@@ -34282,7 +35117,7 @@ var init_historicalSignalsReplayPreparation = __esm({
     prepareHistoricalReplay = async (context, adapters) => {
       const {
         userName: userName3,
-        projectRoot: projectRoot15,
+        projectRoot: projectRoot17,
         preparedRun,
         interval: interval4,
         connectorName,
@@ -34335,7 +35170,7 @@ var init_historicalSignalsReplayPreparation = __esm({
               interval: interval4
             });
             const runtimeLineage = await adapters.buildLineage({
-              projectRoot: projectRoot15,
+              projectRoot: projectRoot17,
               strategyName: strategy.strategyName,
               strategyRevision: strategy.strategyRevision,
               deploymentCompositionId: strategy.deploymentCompositionId,
@@ -34558,11 +35393,11 @@ var init_historicalSignalsReplayResults = __esm({
 });
 
 // src/lib/replay/historicalSignalsReplay.ts
-var import_chalk47, import_progress12, import_strategies12, import_time11, import_logger11, import_redis19, import_connectors17, import_cli13, import_strategies13, import_runtimeStrategies8, loadRuntimeStrategies, loadReferenceConnector, buildAfterSignalsContext, getConnectorName, runHistoricalSignalsReplay;
+var import_chalk49, import_progress12, import_strategies12, import_time11, import_logger11, import_redis19, import_connectors17, import_cli13, import_strategies13, import_runtimeStrategies8, loadRuntimeStrategies, loadReferenceConnector, buildAfterSignalsContext, getConnectorName, runHistoricalSignalsReplay;
 var init_historicalSignalsReplay = __esm({
   "src/lib/replay/historicalSignalsReplay.ts"() {
     "use strict";
-    import_chalk47 = __toESM(require("chalk"));
+    import_chalk49 = __toESM(require("chalk"));
     import_progress12 = __toESM(require("progress"));
     import_strategies12 = require("@tradejs/core/strategies");
     import_time11 = require("@tradejs/core/time");
@@ -34738,8 +35573,8 @@ var init_historicalSignalsReplay = __esm({
             tick: (tokens) => prepareBar.tick(1, tokens)
           },
           display: {
-            skipped: (value) => import_chalk47.default.yellow(value),
-            symbol: (value) => import_chalk47.default.gray(value)
+            skipped: (value) => import_chalk49.default.yellow(value),
+            symbol: (value) => import_chalk49.default.gray(value)
           },
           buildLineage: buildRuntimeLineage
         }
@@ -34771,9 +35606,9 @@ var init_historicalSignalsReplay = __esm({
             tick: (tokens) => cycleBar.tick(1, tokens)
           },
           display: {
-            signals: (value) => import_chalk47.default.cyan(value),
-            aborted: (value) => import_chalk47.default.yellow(value),
-            timestamp: (value) => import_chalk47.default.gray((0, import_time11.formatUnix)(value))
+            signals: (value) => import_chalk49.default.cyan(value),
+            aborted: (value) => import_chalk49.default.yellow(value),
+            timestamp: (value) => import_chalk49.default.gray((0, import_time11.formatUnix)(value))
           },
           invokeBeforeSignals: invokeBeforeSignalsHooks,
           invokeAfterSignals: invokeAfterSignalsHooks,
@@ -34784,7 +35619,7 @@ var init_historicalSignalsReplay = __esm({
       );
       const artifacts = replayConnector.getReplayArtifacts();
       import_logger11.logger.info(
-        import_chalk47.default.gray(
+        import_chalk49.default.gray(
           `signals replay historical cycles: ${plan.orderedTimestamps.length} (aborted=${execution.abortedCycles}) done in ${((Date.now() - startedAt) / 1e3).toFixed(1)}s`
         )
       );
@@ -34897,11 +35732,11 @@ var init_chartSnapshot = __esm({
 });
 
 // src/lib/replay/resultsReporting.ts
-var import_chalk48, saveAndPrintReplayResultsByStrategy;
+var import_chalk50, saveAndPrintReplayResultsByStrategy;
 var init_resultsReporting = __esm({
   "src/lib/replay/resultsReporting.ts"() {
     "use strict";
-    import_chalk48 = __toESM(require("chalk"));
+    import_chalk50 = __toESM(require("chalk"));
     init_runtimeParity();
     init_runFormatting();
     init_support();
@@ -34940,14 +35775,14 @@ var init_resultsReporting = __esm({
       const rows = summaries.map((summary) => {
         const profit = `${summary.netProfit.toFixed(2)}$`;
         const avgTrade = `${summary.avgTradeProfit.toFixed(2)}$`;
-        const profitColor = summary.netProfit > 0 ? import_chalk48.default.green : summary.netProfit < 0 ? import_chalk48.default.red : import_chalk48.default.gray;
-        const avgTradeColor = summary.avgTradeProfit > 0 ? import_chalk48.default.green : summary.avgTradeProfit < 0 ? import_chalk48.default.red : import_chalk48.default.gray;
+        const profitColor = summary.netProfit > 0 ? import_chalk50.default.green : summary.netProfit < 0 ? import_chalk50.default.red : import_chalk50.default.gray;
+        const avgTradeColor = summary.avgTradeProfit > 0 ? import_chalk50.default.green : summary.avgTradeProfit < 0 ? import_chalk50.default.red : import_chalk50.default.gray;
         return [
-          import_chalk48.default.blue(summary.strategyName),
-          import_chalk48.default.yellow(String(summary.tickers)),
-          import_chalk48.default.yellow(String(summary.tickersWithTrades)),
-          import_chalk48.default.cyan(String(summary.orders)),
-          import_chalk48.default.cyan(
+          import_chalk50.default.blue(summary.strategyName),
+          import_chalk50.default.yellow(String(summary.tickers)),
+          import_chalk50.default.yellow(String(summary.tickersWithTrades)),
+          import_chalk50.default.cyan(String(summary.orders)),
+          import_chalk50.default.cyan(
             `${summary.wins}/${summary.losses} (${summary.winRate.toFixed(2)}%)`
           ),
           profitColor(profit),
@@ -36417,29 +37252,29 @@ var init_runtimeComparisonCalculations = __esm({
 });
 
 // src/lib/replay/runtimeComparisonReporting.ts
-var import_chalk49, import_time13, formatDrilldownSummary, colorizeRows, buildReplayComparisonReport, buildNoExchangeEntriesReport, buildNoRuntimeTradesReport, writeReplayComparisonReport;
+var import_chalk51, import_time13, formatDrilldownSummary, colorizeRows, buildReplayComparisonReport, buildNoExchangeEntriesReport, buildNoRuntimeTradesReport, writeReplayComparisonReport;
 var init_runtimeComparisonReporting = __esm({
   "src/lib/replay/runtimeComparisonReporting.ts"() {
     "use strict";
-    import_chalk49 = __toESM(require("chalk"));
+    import_chalk51 = __toESM(require("chalk"));
     import_time13 = require("@tradejs/core/time");
     init_runFormatting();
     init_support();
     formatDrilldownSummary = (summary) => Object.entries(summary).filter(([, count]) => count > 0).map(([classification, count]) => `${classification}=${count}`).join(", ");
     colorizeRows = (rows) => rows.map((row) => {
-      const btPnlColor = row.backtestNetProfit > 0 ? import_chalk49.default.green : row.backtestNetProfit < 0 ? import_chalk49.default.red : import_chalk49.default.gray;
-      const rtPnlColor = row.runtimePnl > 0 ? import_chalk49.default.green : row.runtimePnl < 0 ? import_chalk49.default.red : import_chalk49.default.gray;
+      const btPnlColor = row.backtestNetProfit > 0 ? import_chalk51.default.green : row.backtestNetProfit < 0 ? import_chalk51.default.red : import_chalk51.default.gray;
+      const rtPnlColor = row.runtimePnl > 0 ? import_chalk51.default.green : row.runtimePnl < 0 ? import_chalk51.default.red : import_chalk51.default.gray;
       return [
-        import_chalk49.default.blue(row.strategyName),
-        import_chalk49.default.cyan(String(row.backtestEntries)),
+        import_chalk51.default.blue(row.strategyName),
+        import_chalk51.default.cyan(String(row.backtestEntries)),
         btPnlColor(`${row.backtestNetProfit.toFixed(2)}$`),
-        import_chalk49.default.yellow(String(row.runtimeTrades)),
+        import_chalk51.default.yellow(String(row.runtimeTrades)),
         rtPnlColor(`${row.runtimePnl.toFixed(2)}$`),
-        import_chalk49.default.green(String(row.matched)),
-        import_chalk49.default.red(String(row.orderFailed)),
-        import_chalk49.default.yellow(String(row.runtimeOnly)),
-        import_chalk49.default.magenta(String(row.backtestOnly)),
-        import_chalk49.default.red(String(getReplayRuntimeUnmatchedCount(row)))
+        import_chalk51.default.green(String(row.matched)),
+        import_chalk51.default.red(String(row.orderFailed)),
+        import_chalk51.default.yellow(String(row.runtimeOnly)),
+        import_chalk51.default.magenta(String(row.backtestOnly)),
+        import_chalk51.default.red(String(getReplayRuntimeUnmatchedCount(row)))
       ];
     });
     buildReplayComparisonReport = (context) => {
@@ -36459,7 +37294,7 @@ var init_runtimeComparisonReporting = __esm({
       ];
       if (runtimeOnlyDrilldownSummary || backtestOnlyDrilldownSummary) {
         lines.push(
-          import_chalk49.default.gray(
+          import_chalk51.default.gray(
             `Mismatch drilldown: ${runtimeOnlyLabel}=[${runtimeOnlyDrilldownSummary || "none"}], backtestOnly=[${backtestOnlyDrilldownSummary || "none"}]`
           )
         );
@@ -36472,7 +37307,7 @@ var init_runtimeComparisonReporting = __esm({
       window
     }) => [
       "",
-      import_chalk49.default.yellow(
+      import_chalk51.default.yellow(
         `SIGNALS REPLAY VS EXCHANGE: no lineage-linked exchange entry executions found for ${connectorName} in ${(0, import_time13.formatUnix)(
           window.start
         )} -> ${(0, import_time13.formatUnix)(window.end)}`
@@ -36484,7 +37319,7 @@ var init_runtimeComparisonReporting = __esm({
       window
     }) => [
       "",
-      import_chalk49.default.yellow(
+      import_chalk51.default.yellow(
         `SIGNALS REPLAY VS RUNTIME: no local runtime trades found for ${connectorName} in ${(0, import_time13.formatUnix)(
           window.start
         )} -> ${(0, import_time13.formatUnix)(window.end)} with matching lineage; checking lineage-linked exchange executions`
@@ -36500,11 +37335,11 @@ var init_runtimeComparisonReporting = __esm({
 });
 
 // src/lib/replay/runtimeComparison.ts
-var import_chalk50, getReplayEntryTimestampCompareOffsetMs, buildReplaySignalEvaluations, toFiniteNumberOrNull4, sumOptionalNumbers, firstFiniteNumber, firstString, getExchangeExecutionMergeKey, mergeExchangeExecutionGroup, mergeExchangeEntryExecutions, loadExchangeEntryRows, loadExchangeEntriesForComparison, saveAndPrintReplayExchangeComparison, saveAndPrintReplayRuntimeComparison;
+var import_chalk52, getReplayEntryTimestampCompareOffsetMs, buildReplaySignalEvaluations, toFiniteNumberOrNull4, sumOptionalNumbers, firstFiniteNumber, firstString, getExchangeExecutionMergeKey, mergeExchangeExecutionGroup, mergeExchangeEntryExecutions, loadExchangeEntryRows, loadExchangeEntriesForComparison, saveAndPrintReplayExchangeComparison, saveAndPrintReplayRuntimeComparison;
 var init_runtimeComparison = __esm({
   "src/lib/replay/runtimeComparison.ts"() {
     "use strict";
-    import_chalk50 = __toESM(require("chalk"));
+    import_chalk52 = __toESM(require("chalk"));
     init_runtimeParity();
     init_paritySummary();
     init_runtimeRedis();
@@ -36641,7 +37476,7 @@ var init_runtimeComparison = __esm({
     }) => {
       if (typeof connector.getEntryExecutions !== "function") {
         console.log(
-          import_chalk50.default.yellow(
+          import_chalk52.default.yellow(
             "runtime compare: connector does not support entry execution history"
           )
         );
@@ -36658,7 +37493,7 @@ var init_runtimeComparison = __esm({
           });
           if (chunkRows.length >= 100) {
             console.log(
-              import_chalk50.default.yellow(
+              import_chalk52.default.yellow(
                 "runtime compare: exchange entry executions returned 100 rows (connector cap); older entry trades in this chunk may be truncated"
               )
             );
@@ -36666,7 +37501,7 @@ var init_runtimeComparison = __esm({
           rows.push(...chunkRows);
         } catch (error) {
           console.log(
-            import_chalk50.default.yellow(
+            import_chalk52.default.yellow(
               `runtime compare: getEntryExecutions failed: ${formatRuntimeTradeSyncError(error)}`
             )
           );
@@ -36691,21 +37526,21 @@ var init_runtimeComparison = __esm({
         callbacks: {
           onUnsupported: () => {
             console.log(
-              import_chalk50.default.yellow(
+              import_chalk52.default.yellow(
                 "runtime compare: connector does not support getClosedPnl, using runtime trade records as-is"
               )
             );
           },
           onCapped: () => {
             console.log(
-              import_chalk50.default.yellow(
+              import_chalk52.default.yellow(
                 "runtime compare: exchange closed pnl returned 100 rows (connector cap); older closed trades in the window may be truncated"
               )
             );
           },
           onError: (error) => {
             console.log(
-              import_chalk50.default.yellow(
+              import_chalk52.default.yellow(
                 `runtime compare: getClosedPnl failed: ${formatRuntimeTradeSyncError(error)}`
               )
             );
@@ -36927,7 +37762,7 @@ var init_runtimeComparison = __esm({
       ]);
       if (runtimeEvidence2) {
         console.log(
-          import_chalk50.default.gray(
+          import_chalk52.default.gray(
             `runtime compare: using immutable evidence ${runtimeEvidence2.path}`
           )
         );
@@ -36941,7 +37776,7 @@ var init_runtimeComparison = __esm({
         openPositionCallbacks: {
           onError: (error) => {
             console.log(
-              import_chalk50.default.yellow(
+              import_chalk52.default.yellow(
                 `runtime compare: getOpenPositionPnl failed: ${formatRuntimeTradeSyncError(error)}; continuing without open-position mark prices`
               )
             );
@@ -36950,21 +37785,21 @@ var init_runtimeComparison = __esm({
         closedPnlCallbacks: {
           onUnsupported: () => {
             console.log(
-              import_chalk50.default.yellow(
+              import_chalk52.default.yellow(
                 "runtime compare: connector does not support getClosedPnl, using runtime trade records as-is"
               )
             );
           },
           onCapped: () => {
             console.log(
-              import_chalk50.default.yellow(
+              import_chalk52.default.yellow(
                 "runtime compare: exchange closed pnl returned 100 rows (connector cap); older closed trades in the window may be truncated"
               )
             );
           },
           onError: (error) => {
             console.log(
-              import_chalk50.default.yellow(
+              import_chalk52.default.yellow(
                 `runtime compare: getClosedPnl failed: ${formatRuntimeTradeSyncError(error)}`
               )
             );
@@ -37060,12 +37895,12 @@ var init_runtimeComparison = __esm({
 });
 
 // src/lib/replay/outputReport.ts
-var import_promises29, import_node_path24, import_data4, formatMsk, formatNumber5, formatMoney2, formatPct, tableCell, createMarkdownTable2, entryStrategy, entryKey, buildDrilldownMap, buildPerTradeAnalysis, renderMatchedRows, renderRuntimeOnlyRows, renderOrderFailedRows, renderBacktestOnlyRows, renderStrategyRows, renderLineageRows, writeReplayOutputReport;
+var import_promises33, import_node_path30, import_data4, formatMsk, formatNumber5, formatMoney2, formatPct, tableCell, createMarkdownTable2, entryStrategy, entryKey, buildDrilldownMap, buildPerTradeAnalysis, renderMatchedRows, renderRuntimeOnlyRows, renderOrderFailedRows, renderBacktestOnlyRows, renderStrategyRows, renderLineageRows, writeReplayOutputReport;
 var init_outputReport = __esm({
   "src/lib/replay/outputReport.ts"() {
     "use strict";
-    import_promises29 = __toESM(require("fs/promises"));
-    import_node_path24 = __toESM(require("path"));
+    import_promises33 = __toESM(require("fs/promises"));
+    import_node_path30 = __toESM(require("path"));
     import_data4 = require("@tradejs/core/data");
     init_support();
     formatMsk = (timestamp) => typeof timestamp === "number" && Number.isFinite(timestamp) ? new Intl.DateTimeFormat("ru-RU", {
@@ -37357,7 +38192,7 @@ var init_outputReport = __esm({
       ) : "_No replay lineage records._";
     };
     writeReplayOutputReport = async ({
-      projectRoot: projectRoot15,
+      projectRoot: projectRoot17,
       timestamp,
       replayKey,
       userName: userName3,
@@ -37370,8 +38205,8 @@ var init_outputReport = __esm({
       strategySnapshot,
       runtimeComparison
     }) => {
-      const outputDir = import_node_path24.default.resolve(projectRoot15, "data/replay/output");
-      await import_promises29.default.mkdir(outputDir, { recursive: true });
+      const outputDir = import_node_path30.default.resolve(projectRoot17, "data/replay/output");
+      await import_promises33.default.mkdir(outputDir, { recursive: true });
       const perTradeAnalysis = buildPerTradeAnalysis(runtimeComparison);
       const report = {
         reportType: "replay-output",
@@ -37406,8 +38241,8 @@ var init_outputReport = __esm({
         runtimeComparison,
         perTradeAnalysis
       };
-      const markdownPath = import_node_path24.default.join(outputDir, `${timestamp}-replay-report.md`);
-      const jsonPath = import_node_path24.default.join(outputDir, `${timestamp}-replay-report.json`);
+      const markdownPath = import_node_path30.default.join(outputDir, `${timestamp}-replay-report.md`);
+      const jsonPath = import_node_path30.default.join(outputDir, `${timestamp}-replay-report.json`);
       const lines = [
         "# Replay Report",
         "",
@@ -37473,8 +38308,8 @@ var init_outputReport = __esm({
         ""
       ];
       await Promise.all([
-        import_promises29.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
-        import_promises29.default.writeFile(jsonPath, `${(0, import_data4.toJson)(report, true)}
+        import_promises33.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
+        import_promises33.default.writeFile(jsonPath, `${(0, import_data4.toJson)(report, true)}
 `, "utf8")
       ]);
       return {
@@ -37486,11 +38321,11 @@ var init_outputReport = __esm({
 });
 
 // src/scripts/replayRunner.ts
-var import_chalk51, import_constants19, import_data5, import_time14, import_redis21, prepareReplayBinanceMarketContext, finishReplay, replayBacktest;
+var import_chalk53, import_constants19, import_data5, import_time14, import_redis21, prepareReplayBinanceMarketContext, finishReplay, replayBacktest;
 var init_replayRunner = __esm({
   "src/scripts/replayRunner.ts"() {
     "use strict";
-    import_chalk51 = __toESM(require("chalk"));
+    import_chalk53 = __toESM(require("chalk"));
     import_constants19 = require("@tradejs/core/constants");
     import_data5 = require("@tradejs/core/data");
     import_time14 = require("@tradejs/core/time");
@@ -37524,7 +38359,7 @@ var init_replayRunner = __esm({
         aiEnabled: preparedRun.aiEnabled,
         mlEnabled: preparedRun.mlEnabled,
         strategyNames: preparedRun.strategyNames,
-        log: (message) => console.log(import_chalk51.default.gray(message))
+        log: (message) => console.log(import_chalk53.default.gray(message))
       });
     };
     finishReplay = async ({
@@ -37577,8 +38412,8 @@ var init_replayRunner = __esm({
         strategySnapshot: replayStrategySnapshot,
         runtimeComparison: replayRuntimeComparison
       });
-      console.log(import_chalk51.default.green(`Replay report: ${outputReport.markdownPath}`));
-      console.log(import_chalk51.default.green(`Replay report JSON: ${outputReport.jsonPath}`));
+      console.log(import_chalk53.default.green(`Replay report: ${outputReport.markdownPath}`));
+      console.log(import_chalk53.default.green(`Replay report JSON: ${outputReport.jsonPath}`));
       await (0, import_redis21.setData)(
         replayKey,
         {
@@ -37731,9 +38566,9 @@ var init_replayRunner = __esm({
         ),
         strategyNames: replayStrategies.map(({ strategyName }) => strategyName)
       });
-      console.log(import_chalk51.default.yellow(`tickers: ${preparedRun.tickers.length}`));
+      console.log(import_chalk53.default.yellow(`tickers: ${preparedRun.tickers.length}`));
       console.log(
-        import_chalk51.default.gray(
+        import_chalk53.default.gray(
           `mode: replay (${replayStrategies.map(({ strategyName }) => strategyName).join(", ")})`
         )
       );
@@ -37761,14 +38596,14 @@ var init_replayRunner = __esm({
 // src/scripts/replay.ts
 var replay_exports = {};
 __export(replay_exports, {
-  main: () => main43
+  main: () => main45
 });
-var main43;
+var main45;
 var init_replay = __esm({
   "src/scripts/replay.ts"() {
     "use strict";
     init_replayRunner();
-    main43 = async () => {
+    main45 = async () => {
       await replayBacktest();
     };
   }
@@ -37777,15 +38612,15 @@ var init_replay = __esm({
 // src/scripts/signalsSummary.ts
 var signalsSummary_exports = {};
 __export(signalsSummary_exports, {
-  main: () => main44,
+  main: () => main46,
   signalsSummary: () => signalsSummary
 });
-var import_config13, import_args33, import_logger12, import_connectors18, import_runtimeStrategies9, flags30, projectRoot14, SUMMARY_TIMEZONE2, SUMMARY_TIMEZONE_LABEL2, escapeHtml6, formatMskDateTime3, formatSigned3, formatPnlMoneyText, formatWinRateText, resolveSummaryTitle, normalizeStatus, shouldAttachDebugReport, getSummaryDateParts, formatSummaryIsoDayKey, unescapeHtml, stripTelegramHtml, buildSignalsSummaryAttachment, appendReportAttachmentSummary, resolveSummaryConnectorName, groupRuntimeTradesByConnectorScope, syncRuntimeTradeScopes, createRuntimeSignalStats, mergeRuntimeSignalStats, buildSummaryPrelude, resolveTradeStatusEmoji, isTimestampInWindow, isRuntimeTradeClosedInWindow, buildSummaryMessages, signalsSummary, main44;
+var import_config13, import_args35, import_logger12, import_connectors18, import_runtimeStrategies9, flags32, projectRoot16, SUMMARY_TIMEZONE2, SUMMARY_TIMEZONE_LABEL2, escapeHtml6, formatMskDateTime3, formatSigned3, formatPnlMoneyText, formatWinRateText, resolveSummaryTitle, normalizeStatus, shouldAttachDebugReport, getSummaryDateParts, formatSummaryIsoDayKey, unescapeHtml, stripTelegramHtml, buildSignalsSummaryAttachment, appendReportAttachmentSummary, resolveSummaryConnectorName, groupRuntimeTradesByConnectorScope, syncRuntimeTradeScopes, createRuntimeSignalStats, mergeRuntimeSignalStats, buildSummaryPrelude, resolveTradeStatusEmoji, isTimestampInWindow, isRuntimeTradeClosedInWindow, buildSummaryMessages, signalsSummary, main46;
 var init_signalsSummary = __esm({
   "src/scripts/signalsSummary.ts"() {
     "use strict";
     import_config13 = require("dotenv/config");
-    import_args33 = __toESM(require("args"));
+    import_args35 = __toESM(require("args"));
     import_logger12 = require("@tradejs/infra/logger");
     import_connectors18 = require("@tradejs/node/connectors");
     init_runtimeRedis();
@@ -37795,21 +38630,21 @@ var init_signalsSummary = __esm({
     init_runtimeSignalsStorage();
     init_runtimeDebugEvidence();
     import_runtimeStrategies9 = require("@tradejs/node/runtimeStrategies");
-    import_args33.default.option(["u", "user"], "Use user config", "root");
-    import_args33.default.option(
+    import_args35.default.option(["u", "user"], "Use user config", "root");
+    import_args35.default.option(
       "connector",
       "Connector provider or name for summary (e.g. bybit, binance, coinbase, custom)",
       "bybit"
     );
-    import_args33.default.option(["H", "hours"], "Summary window in hours", 24);
-    import_args33.default.option(["P", "printOnly"], "Print summary instead of Telegram", false);
-    import_args33.default.option(
+    import_args35.default.option(["H", "hours"], "Summary window in hours", 24);
+    import_args35.default.option(["P", "printOnly"], "Print summary instead of Telegram", false);
+    import_args35.default.option(
       "debugAttachment",
       "Attach runtime Redis debug JSON for replay diagnostics",
       true
     );
-    flags30 = import_args33.default.parse(process.argv);
-    projectRoot14 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    flags32 = import_args35.default.parse(process.argv);
+    projectRoot16 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     SUMMARY_TIMEZONE2 = "Europe/Moscow";
     SUMMARY_TIMEZONE_LABEL2 = "MSK";
     escapeHtml6 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -37896,7 +38731,7 @@ var init_signalsSummary = __esm({
       return lines.join("\n");
     };
     resolveSummaryConnectorName = async (value) => {
-      const connectorName = await (0, import_connectors18.resolveConnectorName)(value, projectRoot14);
+      const connectorName = await (0, import_connectors18.resolveConnectorName)(value, projectRoot16);
       if (connectorName) {
         return connectorName;
       }
@@ -37961,7 +38796,7 @@ var init_signalsSummary = __esm({
         );
         const connectorFactory = await (0, import_connectors18.getConnectorCreatorByName)(
           connectorName,
-          projectRoot14
+          projectRoot16
         );
         if (!connectorFactory) {
           throw new Error(`Connector "${connectorName}" is not registered`);
@@ -38314,12 +39149,12 @@ none`
     signalsSummary = async () => {
       const hours = Math.max(
         1,
-        Number.parseInt(String(flags30.hours ?? 24), 10) || 24
+        Number.parseInt(String(flags32.hours ?? 24), 10) || 24
       );
       const endTime = Date.now();
       const startTime = endTime - hours * 60 * 60 * 1e3;
       const fallbackConnectorName = await resolveSummaryConnectorName(
-        flags30.connector
+        flags32.connector
       );
       const [
         configuredStrategyNames,
@@ -38328,25 +39163,25 @@ none`
         trades,
         runtimeDeployments
       ] = await Promise.all([
-        (0, import_runtimeStrategyConfigs.loadRuntimeStrategyNames)(flags30.user),
-        loadRuntimeSignals(flags30.user, { startTime, endTime }),
-        loadRuntimeSignalEvaluationStatsBuckets(flags30.user),
-        loadRuntimeTrades(flags30.user),
-        (0, import_runtimeStrategies9.listRuntimeDeployments)({ userName: flags30.user, projectRoot: projectRoot14 })
+        (0, import_runtimeStrategyConfigs.loadRuntimeStrategyNames)(flags32.user),
+        loadRuntimeSignals(flags32.user, { startTime, endTime }),
+        loadRuntimeSignalEvaluationStatsBuckets(flags32.user),
+        loadRuntimeTrades(flags32.user),
+        (0, import_runtimeStrategies9.listRuntimeDeployments)({ userName: flags32.user, projectRoot: projectRoot16 })
       ]);
       const {
         trades: syncedTrades,
         connectorNames,
         scopesCount
       } = await syncRuntimeTradeScopes({
-        userName: flags30.user,
+        userName: flags32.user,
         startTime,
         endTime,
         fallbackConnectorName,
         trades,
         deployments: runtimeDeployments
       });
-      const activeTradeOrderIds = await loadRuntimeActiveTradeOrderIds(flags30.user);
+      const activeTradeOrderIds = await loadRuntimeActiveTradeOrderIds(flags32.user);
       const windowSignals = signals2.filter(
         (signal) => signal.timestamp >= startTime && signal.timestamp < endTime
       );
@@ -38394,10 +39229,10 @@ none`
         windowClosedTrades.length,
         connectorNames.join(",") || fallbackConnectorName,
         scopesCount,
-        flags30.user
+        flags32.user
       );
-      const debugAttachment = shouldAttachDebugReport(flags30.debugAttachment) ? await buildRuntimeDebugReportAttachment({
-        userName: flags30.user,
+      const debugAttachment = shouldAttachDebugReport(flags32.debugAttachment) ? await buildRuntimeDebugReportAttachment({
+        userName: flags32.user,
         startTime,
         endTime,
         signals: debugSignals,
@@ -38405,7 +39240,7 @@ none`
         trades: windowTrades
       }) : null;
       const signalsAttachment = buildSignalsSummaryAttachment({
-        userName: flags30.user,
+        userName: flags32.user,
         endTime,
         content: signalsMessage
       });
@@ -38421,7 +39256,7 @@ none`
         signalsAttachment,
         ...debugAttachment ? [debugAttachment] : []
       ];
-      if (flags30.printOnly) {
+      if (flags32.printOnly) {
         console.log(tradesMessageWithAttachmentSummary);
         console.log("");
         console.log(`Signals attachment: ${signalsAttachment.filename}`);
@@ -38434,20 +39269,20 @@ none`
         return;
       }
       await sendTelegramReport(tradesMessageWithAttachmentSummary, {
-        userName: flags30.user,
+        userName: flags32.user,
         attachments
       });
     };
-    main44 = signalsSummary;
+    main46 = signalsSummary;
   }
 });
 
 // src/scripts/test-ml.ts
 var test_ml_exports = {};
 __export(test_ml_exports, {
-  main: () => main45
+  main: () => main47
 });
-var import_config14, import_constants20, import_ml3, import_registry5, now, INTERVAL_MIN, CANDLES, makeSeries, makeCandles, buildTrendline, main45;
+var import_config14, import_constants20, import_ml3, import_registry5, now, INTERVAL_MIN, CANDLES, makeSeries, makeCandles, buildTrendline, main47;
 var init_test_ml = __esm({
   "src/scripts/test-ml.ts"() {
     "use strict";
@@ -38497,7 +39332,7 @@ var init_test_ml = __esm({
         { timestamp: entryTs - 2 * INTERVAL_MIN * 6e4, value: price * 0.995 }
       ]
     });
-    main45 = async () => {
+    main47 = async () => {
       const defaultConfig = await (0, import_registry5.getStrategyDefaults)("TrendLine", process.cwd());
       if (!defaultConfig) {
         throw new Error(
@@ -38590,9 +39425,9 @@ var init_test_ml = __esm({
 // src/scripts/test.ts
 var test_exports = {};
 __export(test_exports, {
-  main: () => main46
+  main: () => main48
 });
-var import_config15, import_connectors19, getPositions, main46;
+var import_config15, import_connectors19, getPositions, main48;
 var init_test = __esm({
   "src/scripts/test.ts"() {
     "use strict";
@@ -38602,7 +39437,7 @@ var init_test = __esm({
       const res = await connector.getPositions();
       console.log("res", res);
     };
-    main46 = async () => {
+    main48 = async () => {
       const byBitConnector = await import_connectors19.connectors.ByBit({
         userName: "root"
       });
@@ -38614,25 +39449,25 @@ var init_test = __esm({
 // src/scripts/user-add.ts
 var user_add_exports = {};
 __export(user_add_exports, {
-  main: () => main47
+  main: () => main49
 });
-var import_args34, import_chalk52, import_bcryptjs, import_redis22, flags31, main47;
+var import_args36, import_chalk54, import_bcryptjs, import_redis22, flags33, main49;
 var init_user_add = __esm({
   "src/scripts/user-add.ts"() {
     "use strict";
-    import_args34 = __toESM(require("args"));
-    import_chalk52 = __toESM(require("chalk"));
+    import_args36 = __toESM(require("args"));
+    import_chalk54 = __toESM(require("chalk"));
     import_bcryptjs = __toESM(require("bcryptjs"));
     import_redis22 = require("@tradejs/infra/redis");
-    import_args34.default.example("yarn user-add -u myname -p 123456", "Create or update user");
-    import_args34.default.option(["u", "user"], "Username", "");
-    import_args34.default.option(["p", "password"], "Password (plain text)", "");
-    flags31 = import_args34.default.parse(process.argv);
-    main47 = async () => {
-      const userName3 = String(flags31.user || "").trim();
-      const password = String(flags31.password || "");
+    import_args36.default.example("yarn user-add -u myname -p 123456", "Create or update user");
+    import_args36.default.option(["u", "user"], "Username", "");
+    import_args36.default.option(["p", "password"], "Password (plain text)", "");
+    flags33 = import_args36.default.parse(process.argv);
+    main49 = async () => {
+      const userName3 = String(flags33.user || "").trim();
+      const password = String(flags33.password || "");
       if (!userName3 || !password) {
-        console.error(import_chalk52.default.red("Missing -U <user> or -P <password>"));
+        console.error(import_chalk54.default.red("Missing -U <user> or -P <password>"));
         process.exit(1);
       }
       const passwordHash = await import_bcryptjs.default.hash(password, 10);
@@ -38646,7 +39481,7 @@ var init_user_add = __esm({
       await (0, import_redis22.setData)(import_redis22.redisKeys.user(userName3), next, {
         expire: 0
       });
-      console.log(import_chalk52.default.green(`User ${userName3} updated`));
+      console.log(import_chalk54.default.green(`User ${userName3} updated`));
       process.exit(0);
     };
   }
@@ -38656,7 +39491,7 @@ var init_user_add = __esm({
 var cli_exports = {};
 __export(cli_exports, {
   cleanupCliResources: () => cleanupCliResources,
-  main: () => main48,
+  main: () => main50,
   printUsage: () => printUsage3,
   runLoadedModule: () => runLoadedModule
 });
@@ -38698,6 +39533,8 @@ var scriptLoaders = {
   "research:core": () => Promise.resolve().then(() => (init_coreResearch(), coreResearch_exports)),
   results: () => Promise.resolve().then(() => (init_results(), results_exports)),
   "replay-runtime-evidence": () => Promise.resolve().then(() => (init_replayRuntimeEvidence(), replayRuntimeEvidence_exports)),
+  "runtime-feedback-replay": () => Promise.resolve().then(() => (init_runtimeFeedbackReplay2(), runtimeFeedbackReplay_exports)),
+  "runtime-feedback-sync": () => Promise.resolve().then(() => (init_runtimeFeedbackSync2(), runtimeFeedbackSync_exports)),
   "runtime-evidence": () => Promise.resolve().then(() => (init_runtimeEvidence(), runtimeEvidence_exports)),
   "runtime-evidence-sync": () => Promise.resolve().then(() => (init_runtimeEvidenceSync2(), runtimeEvidenceSync_exports)),
   "runtime-scorecard": () => Promise.resolve().then(() => (init_runtimeScorecard2(), runtimeScorecard_exports)),
@@ -38729,14 +39566,14 @@ var runLoadedModule = async (loaded) => {
 var cleanupCliResources = async () => {
   await Promise.allSettled([(0, import_redis23.closeRedisConnection)(), (0, import_client9.closeTimescalePool)()]);
 };
-var main48 = async () => {
-  const [, scriptPath, command = "", ...args35] = process.argv;
+var main50 = async () => {
+  const [, scriptPath, command = "", ...args37] = process.argv;
   const loader = scriptLoaders[command];
   if (!loader) {
     printUsage3();
     process.exit(command ? 1 : 0);
   }
-  const nextArgs = [...args35];
+  const nextArgs = [...args37];
   if (command === "spread:ingest") {
     nextArgs.push("--provider", "binance_coinbase_spread");
   }
@@ -38749,7 +39586,7 @@ var main48 = async () => {
   }
 };
 if (require.main === module) {
-  main48().catch((error) => {
+  main50().catch((error) => {
     console.error(error);
     process.exit(1);
   });