@tradejs/cli 2.0.14 → 2.0.16

package/dist/lib/runtimeScorecard.js

@@ -0,0 +1,442 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/runtimeScorecard.ts
+var runtimeScorecard_exports = {};
+__export(runtimeScorecard_exports, {
+  buildRuntimeScorecard: () => buildRuntimeScorecard,
+  formatRuntimeScorecardMarkdown: () => formatRuntimeScorecardMarkdown
+});
+module.exports = __toCommonJS(runtimeScorecard_exports);
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var asArray = (value) => Array.isArray(value) ? value : [];
+var finiteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var finiteString = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+var round = (value, decimals = 6) => Number(value.toFixed(decimals));
+var unwrapRows = (value, key) => asArray(value).map((item) => asRecord(asRecord(item)?.[key]) ?? asRecord(item)).filter((item) => item != null);
+var runtimePayload = (artifact) => {
+  const root = asRecord(artifact) ?? {};
+  return asRecord(root.runtime) ?? root;
+};
+var runtimeWindow = (artifact) => {
+  const root = asRecord(artifact) ?? {};
+  return asRecord(root.window) ?? asRecord(runtimePayload(artifact).window) ?? {};
+};
+var extractRuntimeRows = (artifact) => {
+  const runtime = runtimePayload(artifact);
+  return {
+    evaluations: unwrapRows(runtime.evaluations, "evaluation"),
+    signals: unwrapRows(runtime.signals, "signal"),
+    trades: unwrapRows(runtime.trades, "trade"),
+    statsBuckets: asArray(runtime.evaluationStatsBuckets).map(asRecord).filter((item) => item != null)
+  };
+};
+var countBy = (items, getter) => {
+  const counts = {};
+  for (const item of items) {
+    const key = getter(item);
+    if (!key) continue;
+    counts[key] = (counts[key] ?? 0) + 1;
+  }
+  return Object.fromEntries(
+    Object.entries(counts).sort(([left], [right]) => left.localeCompare(right))
+  );
+};
+var buildDistributions = ({
+  evaluations,
+  signals
+}) => {
+  const candidates = evaluations.filter(
+    (evaluation) => evaluation.status === "signal"
+  );
+  return {
+    candidatesByStrategy: countBy(
+      candidates,
+      (evaluation) => finiteString(evaluation.strategy)
+    ),
+    orderStatus: countBy(signals, (signal) => finiteString(signal.orderStatus)),
+    skipReasons: countBy(
+      signals,
+      (signal) => finiteString(signal.orderSkipReason)
+    ),
+    aiQuality: countBy(candidates, (evaluation) => {
+      const quality = finiteNumber(asRecord(evaluation.aiAnalysis)?.quality);
+      return quality == null ? null : String(quality);
+    })
+  };
+};
+var buildDistributionDelta = (current, previous) => {
+  const currentTotal = Object.values(current).reduce(
+    (total, value) => total + value,
+    0
+  );
+  const previousTotal = Object.values(previous).reduce(
+    (total, value) => total + value,
+    0
+  );
+  const keys = [
+    .../* @__PURE__ */ new Set([...Object.keys(current), ...Object.keys(previous)])
+  ].sort((left, right) => left.localeCompare(right));
+  return Object.fromEntries(
+    keys.map((key) => {
+      const currentCount = current[key] ?? 0;
+      const previousCount = previous[key] ?? 0;
+      const currentShare = currentTotal > 0 ? currentCount / currentTotal : 0;
+      const previousShare = previousTotal > 0 ? previousCount / previousTotal : 0;
+      return [
+        key,
+        {
+          currentCount,
+          previousCount,
+          currentShare: round(currentShare),
+          previousShare: round(previousShare),
+          shareDelta: round(currentShare - previousShare)
+        }
+      ];
+    })
+  );
+};
+var sum = (values) => round(values.reduce((total, value) => total + (value ?? 0), 0));
+var statsCount = (buckets, field) => sum(buckets.map((bucket) => finiteNumber(asRecord(bucket.stats)?.[field])));
+var tradeTimestamp = (trade) => finiteNumber(trade.exitTimestamp) ?? finiteNumber(trade.lastSyncedAt) ?? finiteNumber(trade.entryTimestamp) ?? 0;
+var dedupeTrades = (artifacts) => {
+  const tradesByOrderId = /* @__PURE__ */ new Map();
+  for (const artifact of artifacts) {
+    for (const trade of extractRuntimeRows(artifact).trades) {
+      const orderId = finiteString(trade.orderId);
+      if (!orderId) continue;
+      const existing = tradesByOrderId.get(orderId);
+      if (!existing || tradeTimestamp(trade) >= tradeTimestamp(existing)) {
+        tradesByOrderId.set(orderId, trade);
+      }
+    }
+  }
+  return [...tradesByOrderId.values()];
+};
+var maxDrawdown = (trades) => {
+  let cumulative = 0;
+  let peak = 0;
+  let drawdown = 0;
+  for (const trade of trades.sort(
+    (left, right) => tradeTimestamp(left) - tradeTimestamp(right)
+  )) {
+    cumulative += finiteNumber(trade.closedPnl) ?? 0;
+    peak = Math.max(peak, cumulative);
+    drawdown = Math.max(drawdown, peak - cumulative);
+  }
+  return round(drawdown);
+};
+var buildRollingPerformance = ({
+  trades,
+  anchorTime,
+  days
+}) => {
+  const startTime = anchorTime - days * 24 * 60 * 60 * 1e3;
+  const closed = trades.filter((trade) => {
+    const exitTimestamp = finiteNumber(trade.exitTimestamp);
+    return trade.status === "closed" && exitTimestamp != null && exitTimestamp >= startTime && exitTimestamp < anchorTime;
+  });
+  const realizedPnl = sum(closed.map((trade) => finiteNumber(trade.closedPnl)));
+  return {
+    days,
+    closedTrades: closed.length,
+    realizedPnl,
+    expectancy: closed.length > 0 ? round(realizedPnl / closed.length) : null,
+    maxDrawdown: maxDrawdown(closed)
+  };
+};
+var getReplayComparison = (artifact) => {
+  const root = asRecord(artifact) ?? {};
+  return asRecord(asRecord(root.replay)?.runtimeComparison) ?? null;
+};
+var getCalibrationSummary = (artifact) => {
+  const root = asRecord(artifact) ?? {};
+  return asRecord(asRecord(root.summary)?.all) ?? null;
+};
+var buildRuntimeScorecard = ({
+  runtimeArtifact,
+  replayEvidenceArtifact,
+  calibrationArtifact,
+  historyRuntimeArtifacts = [],
+  thresholds = {
+    minimumParityRatio: 0.95,
+    maximumSlippageResidualBps: 3,
+    minimumClosedTrades: 20,
+    minimumExpectancy: 0
+  },
+  generatedAt = Date.now()
+}) => {
+  const rows = extractRuntimeRows(runtimeArtifact);
+  const window = runtimeWindow(runtimeArtifact);
+  const startTime = finiteNumber(window.startTime) ?? generatedAt - 864e5;
+  const endTime = finiteNumber(window.endTime) ?? generatedAt;
+  const evaluationsFromStats = statsCount(rows.statsBuckets, "evaluated");
+  const candidatesFromStats = statsCount(rows.statsBuckets, "signals");
+  const signalEvaluations = rows.evaluations.filter(
+    (evaluation) => evaluation.status === "signal"
+  );
+  const gateDecisions = signalEvaluations.map((evaluation) => ({
+    evaluation,
+    decision: finiteString(asRecord(evaluation.aiAnalysis)?.gateDecision)
+  })).filter(
+    ({ decision }) => decision === "approved" || decision === "rejected"
+  );
+  const allocatorDecisions = signalEvaluations.map((evaluation) => asRecord(evaluation.allocatorDecision)).filter((item) => item != null);
+  const riskDecisions = signalEvaluations.map((evaluation) => asRecord(evaluation.riskDecision)).filter((item) => item != null);
+  const orderAttempts = rows.signals.filter(
+    (signal) => signal.orderStatus === "completed" || signal.orderStatus === "failed"
+  );
+  const currentClosedTrades = rows.trades.filter((trade) => {
+    const exitTimestamp = finiteNumber(trade.exitTimestamp);
+    return trade.status === "closed" && exitTimestamp != null && exitTimestamp >= startTime && exitTimestamp < endTime;
+  });
+  const replayComparison = getReplayComparison(replayEvidenceArtifact);
+  const replayCounts = asRecord(replayComparison?.counts);
+  const matched = finiteNumber(replayCounts?.matched) ?? 0;
+  const backtestOnly = finiteNumber(replayCounts?.backtestOnly) ?? 0;
+  const runtimeOnly = finiteNumber(replayCounts?.runtimeOnly) ?? 0;
+  const comparisonTotal = matched + backtestOnly + runtimeOnly;
+  const parityRatio = comparisonTotal > 0 ? matched / comparisonTotal : null;
+  const lineage = asRecord(replayComparison?.lineage);
+  const lineageReason = finiteString(lineage?.reason);
+  const calibration = getCalibrationSummary(calibrationArtifact);
+  const actualSlippageBps = finiteNumber(
+    asRecord(calibration?.signalToFillAdverseBps)?.avg
+  );
+  const residualVsModelBps = finiteNumber(
+    asRecord(calibration?.residualVsCurrentModelBps)?.avg
+  );
+  const historyTrades = dedupeTrades([
+    ...historyRuntimeArtifacts,
+    runtimeArtifact
+  ]);
+  const currentDistributions = buildDistributions(rows);
+  const previousArtifact = historyRuntimeArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
+    const candidateEndTime = finiteNumber(candidateWindow.endTime);
+    return candidateEndTime != null && candidateEndTime <= startTime;
+  }).sort(
+    (left, right) => (finiteNumber(right.window.endTime) ?? 0) - (finiteNumber(left.window.endTime) ?? 0)
+  )[0];
+  const previousDistributions = previousArtifact ? buildDistributions(extractRuntimeRows(previousArtifact.artifact)) : null;
+  const rolling = [7, 30, 90].map(
+    (days) => buildRollingPerformance({
+      trades: [...historyTrades],
+      anchorTime: endTime,
+      days
+    })
+  );
+  const sevenDay = rolling[0];
+  const reactions = [];
+  if (lineageReason) {
+    reactions.push({
+      code: "LINEAGE_NOT_COMPARABLE",
+      severity: "blocking",
+      message: lineageReason
+    });
+  }
+  if (parityRatio != null && parityRatio < thresholds.minimumParityRatio) {
+    reactions.push({
+      code: "PARITY_REGRESSION",
+      severity: "blocking",
+      message: `Parity ${round(parityRatio * 100, 2)}% is below ${round(thresholds.minimumParityRatio * 100, 2)}%.`
+    });
+  }
+  if (residualVsModelBps != null && residualVsModelBps > thresholds.maximumSlippageResidualBps) {
+    reactions.push({
+      code: "SLIPPAGE_DRIFT",
+      severity: "warning",
+      message: `Execution residual ${round(residualVsModelBps, 2)} bps exceeds ${thresholds.maximumSlippageResidualBps} bps.`
+    });
+  }
+  if (sevenDay.closedTrades >= thresholds.minimumClosedTrades && sevenDay.expectancy != null && sevenDay.expectancy < thresholds.minimumExpectancy) {
+    reactions.push({
+      code: "EXPECTANCY_DEGRADATION",
+      severity: "blocking",
+      message: `7d expectancy ${sevenDay.expectancy} is below ${thresholds.minimumExpectancy}.`
+    });
+  }
+  if (sevenDay.closedTrades < thresholds.minimumClosedTrades) {
+    reactions.push({
+      code: "INSUFFICIENT_RECENT_SAMPLE",
+      severity: "info",
+      message: `Only ${sevenDay.closedTrades} closed trades in 7d; ${thresholds.minimumClosedTrades} required for expectancy reaction.`
+    });
+  }
+  const promotionStatus = reactions.some(
+    (reaction) => reaction.severity === "blocking"
+  ) ? "PROMOTION_BLOCKED" : reactions.some((reaction) => reaction.severity === "warning") ? "REVIEW_REQUIRED" : "OBSERVE";
+  return {
+    reportType: "runtime-scorecard",
+    schemaVersion: 1,
+    generatedAt,
+    window: { startTime, endTime },
+    promotionStatus,
+    thresholds,
+    funnel: {
+      evaluations: evaluationsFromStats > 0 ? evaluationsFromStats : rows.evaluations.length,
+      coreCandidates: candidatesFromStats > 0 ? candidatesFromStats : signalEvaluations.length,
+      gate: {
+        available: gateDecisions.length > 0,
+        approved: gateDecisions.filter(
+          ({ decision }) => decision === "approved"
+        ).length,
+        rejected: gateDecisions.filter(
+          ({ decision }) => decision === "rejected"
+        ).length,
+        coverage: signalEvaluations.length ? round(gateDecisions.length / signalEvaluations.length) : null
+      },
+      allocator: {
+        available: allocatorDecisions.length > 0,
+        approved: allocatorDecisions.filter(
+          (decision) => decision.decision === "approved"
+        ).length,
+        rejected: allocatorDecisions.filter(
+          (decision) => decision.decision === "rejected"
+        ).length
+      },
+      risk: {
+        available: riskDecisions.length > 0,
+        approved: riskDecisions.filter(
+          (decision) => decision.decision === "approved"
+        ).length,
+        rejected: riskDecisions.filter(
+          (decision) => decision.decision === "rejected"
+        ).length
+      },
+      orderAttempts: orderAttempts.length,
+      orderFailures: orderAttempts.filter(
+        (signal) => signal.orderStatus === "failed"
+      ).length,
+      balanceRejects: rows.signals.filter(
+        (signal) => /BALANCE|MARGIN/i.test(
+          `${finiteString(signal.orderSkipReason) ?? ""} ${finiteString(signal.orderFailureReason) ?? ""}`
+        )
+      ).length,
+      fills: rows.trades.length,
+      closedTrades: currentClosedTrades.length
+    },
+    realized: {
+      pnl: sum(
+        currentClosedTrades.map((trade) => finiteNumber(trade.closedPnl))
+      ),
+      fees: sum(
+        currentClosedTrades.map((trade) => finiteNumber(trade.totalFee))
+      ),
+      funding: sum(
+        currentClosedTrades.map((trade) => finiteNumber(trade.fundingFee))
+      )
+    },
+    parity: {
+      available: comparisonTotal > 0,
+      matched,
+      backtestOnly,
+      runtimeOnly,
+      ratio: parityRatio == null ? null : round(parityRatio),
+      lineageReason
+    },
+    execution: {
+      available: calibration != null,
+      actualSignalToFillSlippageBps: actualSlippageBps,
+      residualVsCurrentModelBps: residualVsModelBps
+    },
+    rolling,
+    distributions: currentDistributions,
+    distributionChanges: {
+      available: previousDistributions != null,
+      baselineWindow: previousArtifact ? {
+        startTime: finiteNumber(previousArtifact.window.startTime),
+        endTime: finiteNumber(previousArtifact.window.endTime)
+      } : null,
+      metrics: previousDistributions ? Object.fromEntries(
+        Object.entries(currentDistributions).map(([name, current]) => [
+          name,
+          buildDistributionDelta(
+            current,
+            previousDistributions[name]
+          )
+        ])
+      ) : {}
+    },
+    reactions
+  };
+};
+var formatRuntimeScorecardMarkdown = (scorecard) => {
+  const rollingRows = scorecard.rolling.map(
+    (row) => `| ${row.days}d | ${row.closedTrades} | ${row.realizedPnl} | ${row.expectancy ?? "n/a"} | ${row.maxDrawdown} |`
+  ).join("\n");
+  const reactions = scorecard.reactions.length ? scorecard.reactions.map(
+    (reaction) => `- ${reaction.severity.toUpperCase()} \`${reaction.code}\`: ${reaction.message}`
+  ).join("\n") : "- No automatic reactions.";
+  const distributionChanges = Object.entries(
+    scorecard.distributionChanges.metrics
+  ).flatMap(
+    ([metric, values]) => Object.entries(values).map(([value, change]) => ({
+      metric,
+      value,
+      shareDelta: change.shareDelta
+    }))
+  ).sort(
+    (left, right) => Math.abs(right.shareDelta) - Math.abs(left.shareDelta)
+  ).slice(0, 10).map(
+    (change) => `- ${change.metric}.${change.value}: ${change.shareDelta >= 0 ? "+" : ""}${round(change.shareDelta * 100, 2)} pp`
+  ).join("\n");
+  return `# Runtime scorecard
+
+Status: **${scorecard.promotionStatus}**
+
+Window: ${new Date(scorecard.window.startTime).toISOString()} \u2014 ${new Date(scorecard.window.endTime).toISOString()}
+
+## Funnel
+
+- Evaluations: ${scorecard.funnel.evaluations}
+- Core candidates: ${scorecard.funnel.coreCandidates}
+- Gate approvals/rejects: ${scorecard.funnel.gate.approved}/${scorecard.funnel.gate.rejected}
+- Allocator approvals/rejects: ${scorecard.funnel.allocator.available ? `${scorecard.funnel.allocator.approved}/${scorecard.funnel.allocator.rejected}` : "unavailable"}
+- Risk approvals/rejects: ${scorecard.funnel.risk.available ? `${scorecard.funnel.risk.approved}/${scorecard.funnel.risk.rejected}` : "unavailable"}
+- Order attempts/failures: ${scorecard.funnel.orderAttempts}/${scorecard.funnel.orderFailures}
+- Fills: ${scorecard.funnel.fills}
+- Closed trades: ${scorecard.funnel.closedTrades}
+
+## Replay and execution
+
+- Parity: ${scorecard.parity.ratio == null ? "n/a" : `${round(scorecard.parity.ratio * 100, 2)}%`}
+- Runtime/replay mismatches: ${scorecard.parity.backtestOnly + scorecard.parity.runtimeOnly}
+- Actual signal-to-fill slippage: ${scorecard.execution.actualSignalToFillSlippageBps ?? "n/a"} bps
+- Residual vs current model: ${scorecard.execution.residualVsCurrentModelBps ?? "n/a"} bps
+
+## Rolling performance
+
+| Window | Closed | Realized PnL | Expectancy | Max drawdown |
+| --- | ---: | ---: | ---: | ---: |
+${rollingRows}
+
+## Distribution changes
+
+${scorecard.distributionChanges.available ? distributionChanges || "- No distribution changes." : "- Previous comparable artifact is unavailable."}
+
+## Reactions
+
+${reactions}
+`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildRuntimeScorecard,
+  formatRuntimeScorecardMarkdown
+});

package/dist/lib/runtimeTradeSync.js

@@ -281,6 +281,15 @@ var syncRuntimeTrades = async ({
         nextTrade,
         { expire: import_constants.TTL_1M }
       ),
+      (0, import_redis.setHashJsonField)(
+        import_redis.redisKeys.runtimeClosedTradeBucket(
+          userName,
+          (0, import_time.getRuntimeStorageDayKey)(nextTrade.exitTimestamp)
+        ),
+        trade.orderId,
+        nextTrade,
+        { expire: import_constants.TTL_1M }
+      ),
       ...isCurrentActiveTrade ? [(0, import_redis.delKey)(activeTradeKey)] : []
     ]);
     syncedTrades.push(nextTrade);

package/dist/scripts/agentRun.js

@@ -37,7 +37,7 @@ var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 var import_promises = __toESM(require("fs/promises"));
 var import_node_os = __toESM(require("os"));
-var import_node_path2 = __toESM(require("path"));
+var import_node_path = __toESM(require("path"));
 var import_node_child_process = require("child_process");
 var import_constants = require("@tradejs/core/constants");
 var import_redis = require("@tradejs/infra/redis");
@@ -113,17 +113,9 @@ ${chunk}`, {
 };
 
 // src/lib/researchAgent.ts
-var import_node_path = __toESM(require("path"));
 var RESEARCH_AGENT_MODEL = "openai/gpt-5.4";
 var RESEARCH_AGENT_REASONING_EFFORT = "medium";
 var RESEARCH_AGENT_BRANCH_PREFIX = "codex/research";
-var toUpperSnakeCase = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
-var RESEARCH_NOTE_FILE_OVERRIDES = {
-  TrendLine: "AI_TRENDLINE_REPLAY_NOTES.md",
-  ReverseTrendLine: "AI_REVERSE_TRENDLINE_REPLAY_NOTES.md",
-  AdaptiveMomentumRibbon: "AI_ADAPTIVE_MOMENTUM_RIBBON_REPLAY_NOTES.md",
-  VolumeDivergence: "AI_VOLUME_DIVERGENCE_REPLAY_NOTES.md"
-};
 var buildResearchAgentBranchName = (strategy, runId) => {
   const normalizedStrategy = strategy.trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^a-zA-Z0-9-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
   const normalizedRunId = runId.trim().replace(/[^a-zA-Z0-9-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
@@ -131,13 +123,8 @@ var buildResearchAgentBranchName = (strategy, runId) => {
 };
 var buildResearchAgentCommitMessage = (strategy, runId) => `Research agent: ${strategy} follow-up for ${runId}`;
 var buildResearchAgentPrTitle = (strategy, runId) => `Research agent: ${strategy} follow-up for ${runId}`;
-var getResearchAgentNotePath = (strategy) => import_node_path.default.join(
-  "notes",
-  RESEARCH_NOTE_FILE_OVERRIDES[strategy] || `AI_${toUpperSnakeCase(strategy)}_REPLAY_NOTES.md`
-);
 var getResearchAgentAllowedPathPrefixes = (strategy) => [
-  `packages/strategies/src/${strategy}/`,
-  getResearchAgentNotePath(strategy)
+  `packages/strategies/src/${strategy}/`
 ];
 var parseGithubRepositoryFromRemote = (value) => {
   const trimmed = value.trim();
@@ -263,7 +250,7 @@ Output ONLY one of:
 
 Rules:
 - Keep the patch small and surgical.
-- Prefer strategy-scoped tests and notes updates over broad refactors.
+- Prefer strategy-scoped tests over broad refactors.
 - If you change strategy logic, also add or update tests in the same strategy directory.
 - Do not touch package boundaries or unrelated files.
 - Do not add markdown fences, commentary, or explanations.
@@ -332,7 +319,7 @@ var listFilesRecursive = async (targetPath) => {
     const entries = await import_promises.default.readdir(targetPath, { withFileTypes: true });
     const nested = await Promise.all(
       entries.map(async (entry) => {
-        const absolutePath = import_node_path2.default.join(targetPath, entry.name);
+        const absolutePath = import_node_path.default.join(targetPath, entry.name);
         if (entry.isDirectory()) {
           return listFilesRecursive(absolutePath);
         }
@@ -345,27 +332,21 @@ var listFilesRecursive = async (targetPath) => {
   }
 };
 var collectStrategyContextFiles = async (worktreePath, strategy) => {
-  const strategyRoot = import_node_path2.default.join(
+  const strategyRoot = import_node_path.default.join(
     worktreePath,
     "packages",
     "strategies",
     "src",
     strategy
   );
-  const notePath = import_node_path2.default.join(worktreePath, getResearchAgentNotePath(strategy));
   const strategyFiles = await listFilesRecursive(strategyRoot);
   const files = strategyFiles.filter(
     (filePath) => /\.(ts|tsx|md)$/.test(filePath)
   );
-  try {
-    await import_promises.default.access(notePath);
-    files.push(notePath);
-  } catch {
-  }
   return [...new Set(files)].sort((left, right) => left.localeCompare(right));
 };
 var renderFileContext = async (worktreePath, filePath) => {
-  const relativePath = import_node_path2.default.relative(worktreePath, filePath).replace(/\\/g, "/");
+  const relativePath = import_node_path.default.relative(worktreePath, filePath).replace(/\\/g, "/");
   const content = await import_promises.default.readFile(filePath, "utf8");
   return [
     `=== FILE: ${relativePath} ===`,
@@ -390,9 +371,12 @@ var buildPrompt = async (worktreePath, run, allowedPaths) => {
       {
         status: run.status,
         finishedAt: run.finishedAt,
+        backtestResultKey: run.artifacts.backtestResultKey,
         backtestResult: run.artifacts.backtestResult,
+        aiExportFile: run.artifacts.aiExportFile,
         aiTrainLocal: run.artifacts.aiTrainLocal,
-        strategyConfig: run.artifacts.strategyConfig
+        strategyConfig: run.artifacts.strategyConfig,
+        backtestConfig: run.artifacts.backtestConfig
       },
       null,
       2
@@ -401,8 +385,9 @@ var buildPrompt = async (worktreePath, run, allowedPaths) => {
     "Task:",
     "- Inspect the research results and current strategy files.",
     "- Produce the smallest safe follow-up patch.",
-    "- Prefer notes and tests if the data does not justify a production logic change.",
+    "- Prefer strategy-scoped tests or NO_CHANGES if the data does not justify a production logic change.",
     "- If you change strategy logic, include matching regression tests.",
+    "- Do not create or modify notes/: local research notes are permanently Git-ignored and are not allowed in agent commits.",
     "",
     contexts.join("\n\n")
   ].join("\n");
@@ -475,8 +460,8 @@ var requestAgentDiff = async (userName, messages) => {
   return normalized;
 };
 var applyDiff = async (worktreePath, diffText) => {
-  const tempDir = await import_promises.default.mkdtemp(import_node_path2.default.join(import_node_os.default.tmpdir(), "tradejs-agent-"));
-  const patchPath = import_node_path2.default.join(tempDir, "agent.patch");
+  const tempDir = await import_promises.default.mkdtemp(import_node_path.default.join(import_node_os.default.tmpdir(), "tradejs-agent-"));
+  const patchPath = import_node_path.default.join(tempDir, "agent.patch");
   try {
     await import_promises.default.writeFile(patchPath, diffText, "utf8");
     await runCommandOrThrow(
@@ -701,8 +686,8 @@ var createGithubPullRequest = async (params) => {
 };
 var createWorktree = async (branchName) => {
   const worktreeToken = branchName.replace(/[/:]+/g, "--");
-  const worktreeRoot = import_node_path2.default.join(projectRoot, ".agent-worktrees");
-  const worktreePath = import_node_path2.default.join(worktreeRoot, worktreeToken);
+  const worktreeRoot = import_node_path.default.join(projectRoot, ".agent-worktrees");
+  const worktreePath = import_node_path.default.join(worktreeRoot, worktreeToken);
   await import_promises.default.mkdir(worktreeRoot, { recursive: true });
   await runCommand("git", ["worktree", "remove", "--force", worktreePath], {
     cwd: projectRoot