@tradejs/cli 3.1.29-beta.289 → 3.1.29-beta.290

package/dist/scripts/replayRunner.js

@@ -4990,7 +4990,13 @@ var loadReplayRuntimeEvidenceMetadata = async (params) => {
     userName: artifact.userName,
     startTime: artifact.startTime,
     endTime: artifact.endTime,
-    deployment: artifact.deployment
+    deployment: artifact.deployment,
+    decisionTraceTargets: unwrapRows(
+      artifact.runtime.trades,
+      "trade"
+    ).flatMap(
+      ({ strategy, symbol, signalTimestamp }) => typeof signalTimestamp === "number" && Number.isFinite(signalTimestamp) && artifact.startTime != null && artifact.endTime != null && signalTimestamp >= artifact.startTime && signalTimestamp < artifact.endTime ? [{ strategy, symbol, signalTimestamp }] : []
+    )
   };
 };
 var buildRuntimeEvidenceLineageScopes = ({
@@ -5593,6 +5599,73 @@ var invokeAfterSignalsHooks = async (hooks, params) => {
   }
 };
 
+// src/lib/replay/historicalSignalsReplayDecisionTrace.ts
+var replayDecisionTraceKey = ({
+  strategy,
+  symbol,
+  signalTimestamp
+}) => JSON.stringify([strategy, symbol, signalTimestamp]);
+var describeOutcome = (result) => {
+  if (typeof result === "string") {
+    return {
+      stage: result.startsWith("BACKTEST_ENTRY_DELAY_") ? "entry_delay" : /(?:NO_PATTERN|POSITION_EXISTS)$/.test(result) ? "core" : "evaluation",
+      reason: result
+    };
+  }
+  if (!result) return { stage: "evaluation", reason: "NO_SIGNAL" };
+  const reason = result.orderSkipReason || result.orderFailureReason || result.orderStatus || "SIGNAL";
+  const patternContext = result.additionalIndicators?.tradingPatternsContext;
+  return {
+    stage: result.riskDecision?.status === "rejected" || /^ENTRY_(?:RR_BELOW|RISK_EXCEEDS)/.test(reason) ? "risk" : /^(?:AI_|ML_|HOOK_BEFORE_ENTRY_GATE|RESEARCH_ENTRY_POLICY)/.test(
+      reason
+    ) ? "gate" : result.orderStatus ? "execution" : "evaluation",
+    reason,
+    direction: result.direction,
+    orderStatus: result.orderStatus,
+    ...typeof patternContext?.selectedPattern === "string" ? { pattern: patternContext.selectedPattern } : {},
+    ...typeof patternContext?.sourceCode === "string" ? { patternCode: patternContext.sourceCode } : {}
+  };
+};
+var createReplayDecisionTrace = (targets = []) => {
+  const traces = /* @__PURE__ */ new Map();
+  const symbols = new Set(targets.map(({ symbol }) => symbol));
+  for (const target of targets) {
+    traces.set(replayDecisionTraceKey(target), {
+      ...target,
+      decision: {
+        stage: "not_evaluated",
+        reason: "REPLAY_CANDLE_NOT_EVALUATED"
+      }
+    });
+  }
+  const record = (strategy, symbol, candle, result, notEvaluatedReason) => {
+    if (!symbols.has(symbol)) return;
+    const { timestamp, open, high, low, close, volume } = candle;
+    const trace = traces.get(
+      replayDecisionTraceKey({ strategy, symbol, signalTimestamp: timestamp })
+    );
+    if (result && typeof result !== "string" && result.timestamp !== timestamp) {
+      const original = traces.get(
+        replayDecisionTraceKey({
+          strategy,
+          symbol,
+          signalTimestamp: result.timestamp
+        })
+      );
+      if (original)
+        original.followUp = {
+          ...describeOutcome(result),
+          candleTimestamp: timestamp
+        };
+      notEvaluatedReason = "REPLAY_PROCESSED_DELAYED_ENTRY";
+    }
+    if (!trace) return;
+    trace.candle = { timestamp, open, high, low, close, volume };
+    trace.decision = notEvaluatedReason ? { stage: "not_evaluated", reason: notEvaluatedReason } : describeOutcome(result);
+  };
+  return { record, values: () => [...traces.values()] };
+};
+
 // src/lib/replay/historicalSignalsReplaySkipEvidence.ts
 var import_data2 = require("@tradejs/core/data");
 var replayScopeKey = (strategy, symbol) => `${strategy}::${symbol}`;
@@ -5703,6 +5776,7 @@ var executeHistoricalReplay = async (context, adapters) => {
     context.plan.runtimeLineages,
     context.collectSkipEvidence
   );
+  const decisionTrace = createReplayDecisionTrace(context.decisionTraceTargets);
   const reportProgress = (timestamp) => {
     if (adapters.progress.enabled === false) return;
     adapters.progress.tick({
@@ -5731,6 +5805,20 @@ var executeHistoricalReplay = async (context, adapters) => {
           status: "completed",
           durationMs: adapters.clock.now() - cycleStartedAt
         });
+        if (context.decisionTraceTargets?.length) {
+          for (const symbolRuntime of cycleSymbols) {
+            const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
+            for (const strategy of symbolRuntime.strategies) {
+              decisionTrace.record(
+                strategy.strategyName,
+                symbolRuntime.symbol,
+                candle,
+                void 0,
+                "REPLAY_CYCLE_ABORTED"
+              );
+            }
+          }
+        }
         advanceAbortedCycle(cycleSymbols, timestamp);
         reportProgress(timestamp);
         continue;
@@ -5741,6 +5829,17 @@ var executeHistoricalReplay = async (context, adapters) => {
         const btcCandle = symbolRuntime.btcReplayData[symbolRuntime.currentIndex];
         const ethCandle = symbolRuntime.ethReplayData[symbolRuntime.currentIndex];
         if (!candle || !btcCandle || candle.timestamp + (symbolRuntime.timestampOffsetMs ?? 0) !== timestamp || btcCandle.timestamp !== candle.timestamp) {
+          if (candle && context.decisionTraceTargets?.length) {
+            for (const strategy of symbolRuntime.strategies) {
+              decisionTrace.record(
+                strategy.strategyName,
+                symbolRuntime.symbol,
+                candle,
+                void 0,
+                "REPLAY_CANDLE_OR_REFERENCE_NOT_ALIGNED"
+              );
+            }
+          }
           continue;
         }
         for (const strategyRuntime of symbolRuntime.strategies) {
@@ -5749,6 +5848,12 @@ var executeHistoricalReplay = async (context, adapters) => {
             btcCandle,
             ethCandle?.timestamp === candle.timestamp ? ethCandle : void 0
           );
+          decisionTrace.record(
+            strategyRuntime.strategyName,
+            symbolRuntime.symbol,
+            candle,
+            result
+          );
           skipEvidence.record({
             strategyName: strategyRuntime.strategyName,
             symbol: symbolRuntime.symbol,
@@ -5780,7 +5885,8 @@ var executeHistoricalReplay = async (context, adapters) => {
   return {
     signals,
     abortedCycles,
-    replayLineageScopes: skipEvidence.values()
+    replayLineageScopes: skipEvidence.values(),
+    replayDecisionTraces: decisionTrace.values()
   };
 };
 
@@ -5831,7 +5937,8 @@ var collectHistoricalReplayResult = (context) => ({
   cycleCount: context.cycleCount,
   abortedCycles: context.abortedCycles,
   runtimeLineages: context.runtimeLineages,
-  replayLineageScopes: context.replayLineageScopes
+  replayLineageScopes: context.replayLineageScopes,
+  ...context.replayDecisionTraces?.length ? { replayDecisionTraces: context.replayDecisionTraces } : {}
 });
 var compactHistoricalReplayResultForPortfolio = (result) => ({
   ...result,
@@ -5877,7 +5984,10 @@ var mergeHistoricalReplayResults = (parts) => {
     cycleCount: parts.reduce((sum, part) => sum + part.cycleCount, 0),
     abortedCycles: parts.reduce((sum, part) => sum + part.abortedCycles, 0),
     runtimeLineages: parts.flatMap((part) => part.runtimeLineages),
-    replayLineageScopes: parts.flatMap((part) => part.replayLineageScopes)
+    replayLineageScopes: parts.flatMap((part) => part.replayLineageScopes),
+    replayDecisionTraces: parts.flatMap(
+      (part) => part.replayDecisionTraces ?? []
+    )
   };
 };
 
@@ -6028,7 +6138,8 @@ var runHistoricalSignalsReplay = async ({
   references,
   showProgress = true,
   collectSkipEvidence = true,
-  collectSignals = true
+  collectSignals = true,
+  decisionTraceTargets
 }) => {
   const memory = createReplayMemoryProfile();
   memory?.("prepare:start");
@@ -6115,6 +6226,7 @@ var runHistoricalSignalsReplay = async ({
       connector: replayConnector,
       collectSkipEvidence,
       collectSignals,
+      decisionTraceTargets,
       hooks: projectHooks,
       hookContext
     },
@@ -6151,7 +6263,8 @@ var runHistoricalSignalsReplay = async ({
     cycleCount: plan.orderedTimestamps.length,
     abortedCycles: execution.abortedCycles,
     runtimeLineages: plan.runtimeLineages,
-    replayLineageScopes: execution.replayLineageScopes
+    replayLineageScopes: execution.replayLineageScopes,
+    replayDecisionTraces: execution.replayDecisionTraces
   });
   memory?.("result:collected");
   return result;
@@ -6379,6 +6492,7 @@ var extractRuntimeParityEntries = (trades) => trades.filter(
   direction: trade.direction,
   qty: toFiniteNumberOrNull2(trade.qty),
   timestamp: trade.entryTimestamp,
+  ...Number.isFinite(trade.signalTimestamp) ? { signalTimestamp: trade.signalTimestamp } : {},
   price: toFiniteNumberOrNull2(trade.entryPrice),
   orderId: trade.orderId,
   signalId: typeof trade.signalId === "string" ? trade.signalId : void 0,
@@ -7124,6 +7238,7 @@ var toRuntimeParityDetail = (entry) => ({
   direction: entry.direction,
   qty: entry.qty ?? null,
   timestamp: entry.timestamp,
+  ...entry.signalTimestamp != null ? { signalTimestamp: entry.signalTimestamp } : {},
   price: entry.price,
   exitType: entry.exitType ?? null,
   exitTimestamp: entry.exitTimestamp ?? null,
@@ -7197,7 +7312,8 @@ var findNearestEvaluation = ({
   evaluations,
   toleranceMs,
   timestampOffsetMs,
-  entryTimestampOffsetMs = 0
+  entryTimestampOffsetMs = 0,
+  matchDirection = false
 }) => {
   const entryStrategy2 = getEntryStrategy(entry);
   if (!entryStrategy2) {
@@ -7207,7 +7323,7 @@ var findNearestEvaluation = ({
   let bestDiff = Number.POSITIVE_INFINITY;
   const entryTimestamp = entry.timestamp + entryTimestampOffsetMs;
   for (const evaluation of evaluations) {
-    if (evaluation.strategy !== entryStrategy2 || evaluation.symbol !== entry.symbol) {
+    if (evaluation.strategy !== entryStrategy2 || evaluation.symbol !== entry.symbol || matchDirection && evaluation.direction != null && evaluation.direction !== entry.direction) {
       continue;
     }
     const diff = Math.abs(
@@ -7553,6 +7669,7 @@ var buildReplayMismatchDrilldown = ({
   replaySignals = [],
   replaySignalEvaluations = [],
   replayLineageScopes = [],
+  replayDecisionTraces = [],
   runtimeLineageScopes = [],
   toleranceMs,
   backtestTimestampOffsetMs,
@@ -7561,48 +7678,66 @@ var buildReplayMismatchDrilldown = ({
   const nearestByEntry = new Map(
     nearestCandidates.map((candidate) => [candidate.entry, candidate])
   );
+  const traceByCandle = new Map(
+    replayDecisionTraces.map((trace) => [replayDecisionTraceKey(trace), trace])
+  );
   const artifactLimit = Math.min(limit, resolveReplayParityArtifactLimit());
   let runtimeOnlyArtifactsIncluded = 0;
   let backtestOnlyArtifactsIncluded = 0;
   const runtimeOnlyDiagnostics = runtimeOnly.map((entry, index) => {
-    const entryOffsetMs = resolveTradeParityTimestampOffset(
-      getEntryStrategy(entry) ?? "",
-      backtestTimestampOffsetMs
-    );
+    const isRuntimeTrade = entry.source === "runtime";
+    const decisionEntry = isRuntimeTrade ? entry.signalTimestamp == null ? null : { ...entry, timestamp: entry.signalTimestamp } : entry;
+    const decisionClock = {
+      toleranceMs: isRuntimeTrade ? 0 : toleranceMs,
+      timestampOffsetMs: isRuntimeTrade ? 0 : resolveTradeParityTimestampOffset(
+        getEntryStrategy(entry) ?? "",
+        backtestTimestampOffsetMs
+      )
+    };
     const includeArtifacts = index < artifactLimit;
     const nearestCandidate = nearestByEntry.get(entry);
-    const nearestReplaySignal = findNearestSignal({
-      entry,
+    const nearestReplaySignal = decisionEntry && findNearestSignal({
+      entry: decisionEntry,
       signals: replaySignals,
-      toleranceMs,
-      timestampOffsetMs: entryOffsetMs
+      ...decisionClock
     });
-    const nearestReplayEvaluation = findNearestEvaluation({
-      entry,
+    const nearestReplayEvaluation = decisionEntry && findNearestEvaluation({
+      entry: decisionEntry,
       evaluations: replaySignalEvaluations,
-      toleranceMs,
-      timestampOffsetMs: entryOffsetMs
+      matchDirection: isRuntimeTrade,
+      ...decisionClock
     });
-    const nearestReplayEvaluationOutcome = findNearestReplayEvaluationOutcome({
-      entry,
+    const nearestReplayEvaluationOutcome = decisionEntry && findNearestReplayEvaluationOutcome({
+      entry: decisionEntry,
       lineageScopes: replayLineageScopes,
-      toleranceMs,
-      timestampOffsetMs: entryOffsetMs
+      ...decisionClock
     });
+    const strategy = getEntryStrategy(entry);
+    const replayDecisionTrace = isRuntimeTrade && strategy && decisionEntry ? traceByCandle.get(
+      replayDecisionTraceKey({
+        strategy,
+        symbol: entry.symbol,
+        signalTimestamp: decisionEntry.timestamp
+      })
+    ) : void 0;
+    const unavailableReason = !isRuntimeTrade ? "no_replay_signal_or_backtest_candidate" : !decisionEntry ? "replay_signal_timestamp_unavailable" : replayDecisionTrace?.decision.stage === "not_evaluated" ? replayDecisionTrace.decision.reason : "replay_evaluation_unavailable";
     const classification = nearestReplaySignal ? classifySignalDiagnostic(nearestReplaySignal.signal) : nearestReplayEvaluation ? classifyEvaluationDiagnostic(nearestReplayEvaluation.evaluation) : nearestReplayEvaluationOutcome ? {
-      classification: "core_skipped",
+      classification: nearestReplayEvaluationOutcome.reason.startsWith(
+        "BACKTEST_ENTRY_DELAY_"
+      ) ? "entry_delayed" : "core_skipped",
       reason: nearestReplayEvaluationOutcome.reason
-    } : nearestCandidate?.nearest ? {
+    } : !isRuntimeTrade && nearestCandidate?.nearest ? {
       classification: "timing_or_price_drift",
       reason: nearestCandidate.reason
     } : {
       classification: "no_replay_candidate",
-      reason: "no_replay_signal_or_backtest_candidate"
+      reason: unavailableReason
     };
     return {
       entry,
       ...classification,
       ...nearestCandidate ? { nearestCandidate } : {},
+      ...replayDecisionTrace ? { replayDecisionTrace } : {},
       ...nearestReplaySignal ? {
         replaySignal: toSignalDiagnostic({
           signal: nearestReplaySignal.signal,
@@ -7728,6 +7863,7 @@ var buildReplayRuntimeComparisonDetails = ({
   replaySignals,
   replaySignalEvaluations,
   replayLineageScopes,
+  replayDecisionTraces,
   runtimeLineageScopes
 }) => {
   const runtimeDetails = runtimeEntries.map(toRuntimeParityDetail);
@@ -7788,6 +7924,7 @@ var buildReplayRuntimeComparisonDetails = ({
       replaySignals,
       replaySignalEvaluations,
       replayLineageScopes,
+      replayDecisionTraces,
       runtimeLineageScopes,
       toleranceMs,
       backtestTimestampOffsetMs,
@@ -8813,6 +8950,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
   replaySignals,
   replayLineages,
   replayLineageScopes,
+  replayDecisionTraces,
   runtimeEvidencePath
 }) => {
   const { connector, connectorName, window } = getRuntimeCompareContext();
@@ -8964,7 +9102,8 @@ var saveAndPrintReplayRuntimeComparison = async ({
     replaySignals,
     replaySignalEvaluations,
     runtimeLineageScopes: comparable.runtimeLineageScopes,
-    replayLineageScopes
+    replayLineageScopes,
+    replayDecisionTraces
   });
   const parityRows = summarizeTradeParityByStrategy({
     runtimeEntries: runtimeDedupe.entries,
@@ -9891,6 +10030,7 @@ var finishReplay = async ({
     replaySignals: replayResult.signals,
     replayLineages: replayResult.runtimeLineages,
     replayLineageScopes: replayResult.replayLineageScopes,
+    replayDecisionTraces: replayResult.replayDecisionTraces,
     runtimeEvidencePath: replayRuntimeEvidencePath
   });
   const finishedAt = /* @__PURE__ */ new Date();
@@ -10240,7 +10380,8 @@ var replayBacktest = async () => {
       references: historicalReplayReferences,
       showProgress: !replayFlags.portfolioReport,
       collectSkipEvidence: !replayFlags.portfolioReport,
-      collectSignals: !replayFlags.portfolioReport
+      collectSignals: !replayFlags.portfolioReport,
+      decisionTraceTargets: replayFlags.portfolioReport ? void 0 : evidenceMetadata?.decisionTraceTargets
     });
     return replayFlags.portfolioReport ? compactHistoricalReplayResultForPortfolio(result) : result;
   };

package/dist/scripts/runtimeFeedbackNotify.js

@@ -39,6 +39,9 @@ var import_node_path = __toESM(require("path"));
 var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 
+// src/lib/runtimeFeedbackNotification.ts
+var import_userSettings = require("@tradejs/infra/userSettings");
+
 // src/lib/runtimeFeedbackArtifacts.ts
 var runtimeFeedbackArtifacts_exports = {};
 __reExport(runtimeFeedbackArtifacts_exports, require("@tradejs/node/diagnostics"));
@@ -223,11 +226,14 @@ var notifyRuntimeFeedbackBundle = async ({
 }) => {
   const verified = await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(bundleDir);
   const message = buildRuntimeFeedbackTelegramMessage(verified.replayEvidence);
-  await send(message, { userName: verified.manifest.userName });
+  const settings = await (0, import_userSettings.getUserSettings)(verified.manifest.userName);
+  const sent = settings.NOTIFY_RUNTIME_DEBUG !== false;
+  if (sent) await send(message, { userName: verified.manifest.userName });
   return {
     artifactId: verified.manifest.artifactId,
     userName: verified.manifest.userName,
-    message
+    message,
+    sent
   };
 };
 
@@ -249,7 +255,9 @@ var runtimeFeedbackNotify = async () => {
   }
   const result = await notifyRuntimeFeedbackBundle({ bundleDir });
   console.log(
-    import_chalk.default.green(`Runtime feedback notification sent: ${result.artifactId}`)
+    import_chalk.default.green(
+      `Runtime feedback notification ${result.sent ? "sent" : "disabled"}: ${result.artifactId}`
+    )
   );
 };
 var main = runtimeFeedbackNotify;

package/dist/scripts/runtimeFeedbackReplay.js

@@ -43,6 +43,7 @@ var import_chalk = __toESM(require("chalk"));
 var import_node_child_process = require("child_process");
 var import_promises = __toESM(require("fs/promises"));
 var import_node_path = __toESM(require("path"));
+var import_mcp = require("@tradejs/node/mcp");
 
 // src/lib/runtimeEvidenceDeployment.ts
 var runtimeEvidenceDeployment_exports = {};
@@ -190,44 +191,58 @@ var runLoggedCommand = async ({
   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_process.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);
-    });
+  await logHandle.writeFile(
+    "\n" + (0, import_mcp.formatMcpArtifactLogLine)(`$ ${[executable, ...command].join(" ")}`)
+  );
+  const child = (0, import_node_child_process.spawn)(executable, command, {
+    cwd,
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const exit = new Promise((resolve, reject) => {
     child.once("error", reject);
     child.once("close", (code, signal) => {
-      void pendingLogWrite.then(() => {
-        if (code === 0) {
-          resolve();
-          return;
-        }
+      if (code === 0) resolve();
+      else {
         reject(
           new Error(
             `Runtime feedback command failed: exit=${String(code)} signal=${String(signal)}`
           )
         );
-      }, reject);
+      }
     });
   });
+  let pendingLogWrite = Promise.resolve();
+  const copyLog = async (input, output) => {
+    const writeLine = async (line) => {
+      const formatted = (0, import_mcp.formatMcpArtifactLogLine)(line);
+      pendingLogWrite = pendingLogWrite.then(
+        () => logHandle.writeFile(formatted)
+      );
+      await pendingLogWrite;
+      output.write(formatted);
+    };
+    let pendingLine = "";
+    try {
+      for await (const chunk of input.setEncoding("utf8")) {
+        const lines = (pendingLine + chunk).split("\n");
+        pendingLine = lines.pop() ?? "";
+        for (const line of lines) await writeLine(line);
+      }
+      if (pendingLine) await writeLine(pendingLine);
+    } catch (error) {
+      child.kill();
+      throw error;
+    }
+  };
+  const results = await Promise.allSettled([
+    copyLog(child.stdout, process.stdout),
+    copyLog(child.stderr, process.stderr),
+    exit
+  ]);
+  for (const result of results) {
+    if (result.status === "rejected") throw result.reason;
+  }
 };
 var runRuntimeFeedbackReplay = async ({
   runtimeEvidencePath,

package/dist/scripts/runtimeParity.js

@@ -159,6 +159,7 @@ var extractRuntimeParityEntries = (trades) => trades.filter(
   direction: trade.direction,
   qty: toFiniteNumberOrNull(trade.qty),
   timestamp: trade.entryTimestamp,
+  ...Number.isFinite(trade.signalTimestamp) ? { signalTimestamp: trade.signalTimestamp } : {},
   price: toFiniteNumberOrNull(trade.entryPrice),
   orderId: trade.orderId,
   signalId: typeof trade.signalId === "string" ? trade.signalId : void 0,

package/dist/scripts/signalsSummary.js

@@ -35,6 +35,7 @@ __export(signalsSummary_exports, {
 });
 module.exports = __toCommonJS(signalsSummary_exports);
 var import_config = require("dotenv/config");
+var import_userSettings = require("@tradejs/infra/userSettings");
 var import_args = __toESM(require("args"));
 var import_logger = require("@tradejs/infra/logger");
 var import_connectors = require("@tradejs/node/connectors");
@@ -1295,6 +1296,7 @@ none`
   };
 };
 var signalsSummary = async () => {
+  const includeDebug = flags.printOnly || (await (0, import_userSettings.getUserSettings)(flags.user)).NOTIFY_RUNTIME_DEBUG !== false;
   const hours = Math.max(
     1,
     Number.parseInt(String(flags.hours ?? 24), 10) || 24
@@ -1415,18 +1417,15 @@ var signalsSummary = async () => {
       content: signalsMessage,
       deploymentId: scope.deploymentId
     });
-    const tradesMessageWithAttachmentSummary = appendReportAttachmentSummary({
+    const tradesMessageWithAttachmentSummary = includeDebug ? appendReportAttachmentSummary({
       message: tradesMessage,
       signalsFilename: signalsAttachment.filename,
       filename: debugAttachment?.filename,
       tradesCount: debugAttachment ? scopeTrades.length : void 0,
       signalsCount: debugAttachment ? debugAttachment.summary?.signals ?? debugSignals.length : void 0,
       evaluationsCount: debugAttachment ? debugAttachment.summary?.evaluations ?? 0 : void 0
-    });
-    const attachments = [
-      signalsAttachment,
-      ...debugAttachment ? [debugAttachment] : []
-    ];
+    }) : tradesMessage;
+    const attachments = includeDebug ? [signalsAttachment, ...debugAttachment ? [debugAttachment] : []] : [];
     if (flags.printOnly) {
       console.log(tradesMessageWithAttachmentSummary);
       console.log("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/cli",
-  "version": "3.1.29-beta.289",
+  "version": "3.1.29-beta.290",
   "description": "Official CLI for the TradeJS TypeScript framework: infra setup, backtests, signals, bots, and ML workflows.",
   "keywords": [
     "tradejs",
@@ -37,13 +37,13 @@
     "tradejs": "dist/cli.js"
   },
   "dependencies": {
-    "@tradejs/connectors": "^3.1.29-beta.289",
-    "@tradejs/core": "^3.1.29-beta.289",
-    "@tradejs/indicators": "^3.1.29-beta.289",
-    "@tradejs/infra": "^3.1.29-beta.289",
-    "@tradejs/node": "^3.1.29-beta.289",
+    "@tradejs/connectors": "^3.1.29-beta.290",
+    "@tradejs/core": "^3.1.29-beta.290",
+    "@tradejs/indicators": "^3.1.29-beta.290",
+    "@tradejs/infra": "^3.1.29-beta.290",
+    "@tradejs/node": "^3.1.29-beta.290",
     "@tradejs/strategy-kit": "3.0.6",
-    "@tradejs/types": "^3.1.29-beta.289",
+    "@tradejs/types": "^3.1.29-beta.290",
     "args": "^5.0.3",
     "bcryptjs": "^2.4.3",
     "chalk": "4.1.2",