@tradejs/cli 2.0.15 → 2.0.16

package/dist/lib/aiTrainResearch.js

@@ -34,7 +34,8 @@ __export(aiTrainResearch_exports, {
   fingerprintResearchValue: () => fingerprintResearchValue,
   summarizeAiTrainCoverage: () => summarizeAiTrainCoverage,
   summarizeAiTrainRejectReasons: () => summarizeAiTrainRejectReasons,
-  summarizeAiTrainTerminalWindows: () => summarizeAiTrainTerminalWindows
+  summarizeAiTrainTerminalWindows: () => summarizeAiTrainTerminalWindows,
+  writeAiTrainResearchSnapshot: () => writeAiTrainResearchSnapshot
 });
 module.exports = __toCommonJS(aiTrainResearch_exports);
 var import_node_child_process = require("child_process");
@@ -350,6 +351,20 @@ var DERIVATIVES_CONTEXT_DATA_MODEL = {
   hyperliquidWhaleMinCoveragePct: 0.8,
   hyperliquidWhaleDataModelVersion: import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
 };
+var writeAiTrainResearchSnapshot = async ({
+  outputPath,
+  result
+}) => {
+  const resolvedPath = import_node_path.default.resolve(outputPath);
+  await import_promises.default.mkdir(import_node_path.default.dirname(resolvedPath), { recursive: true });
+  await import_promises.default.writeFile(
+    resolvedPath,
+    `${JSON.stringify(result, null, 2)}
+`,
+    "utf8"
+  );
+  return resolvedPath;
+};
 var normalizeForStableJson = (value) => {
   if (Array.isArray(value)) {
     return value.map(normalizeForStableJson);
@@ -464,6 +479,7 @@ var resolveGateFingerprint = async (projectRoot, strategyName, gitSha) => {
     `packages/strategies/src/${strategyName}/guardrails.ts`,
     `packages/strategies/src/${strategyName}/pockets.ts`,
     `packages/strategies/src/${strategyName}/config.ts`,
+    "packages/strategies/src/shared/localAiGate.ts",
     "packages/node/src/ai.ts"
   ];
   const optionalSourceEntries = await Promise.all(
@@ -532,5 +548,6 @@ var buildAiTrainLineage = async ({
   fingerprintResearchValue,
   summarizeAiTrainCoverage,
   summarizeAiTrainRejectReasons,
-  summarizeAiTrainTerminalWindows
+  summarizeAiTrainTerminalWindows,
+  writeAiTrainResearchSnapshot
 });

package/dist/lib/marketContextPrepare.js

@@ -1637,6 +1637,7 @@ var require_list_it = __commonJS({
 var marketContextPrepare_exports = {};
 __export(marketContextPrepare_exports, {
   prepareMarketContextForRun: () => prepareMarketContextForRun,
+  resolveMarketContextRunRequirements: () => resolveMarketContextRunRequirements,
   shouldPrepareBinanceMarketContextForRun: () => shouldPrepareBinanceMarketContextForRun,
   shouldPrepareCoinMarketCapContextForRun: () => shouldPrepareCoinMarketCapContextForRun,
   shouldPrepareDerivativesContextForRun: () => shouldPrepareDerivativesContextForRun,
@@ -1644,6 +1645,8 @@ __export(marketContextPrepare_exports, {
 });
 module.exports = __toCommonJS(marketContextPrepare_exports);
 var import_chalk4 = __toESM(require("chalk"));
+var import_timescale5 = require("@tradejs/infra/timescale");
+var import_registry = require("@tradejs/node/registry");
 
 // src/lib/binanceMarketContextBackfill.ts
 var import_progress = __toESM(require("progress"));
@@ -4904,6 +4907,9 @@ var backfillHyperliquidWhaleContext = async (params) => {
 };
 
 // src/lib/marketContextPrepare.ts
+var uniqueReasons = (reasons) => [
+  ...new Set(reasons)
+];
 var shouldPrepareDerivativesContextForRun = (params) => {
   if (params.universe === "tradfi") return false;
   if (params.mode === "signals") {
@@ -4911,6 +4917,9 @@ var shouldPrepareDerivativesContextForRun = (params) => {
       cacheOnly: params.cacheOnly
     });
   }
+  if (params.mode === "backtest" && !params.aiEnabled && !params.mlEnabled) {
+    return false;
+  }
   return shouldBackfillDerivativesContextForBacktest({
     aiEnabled: Boolean(params.aiEnabled),
     cacheOnly: params.cacheOnly,
@@ -4920,6 +4929,7 @@ var shouldPrepareDerivativesContextForRun = (params) => {
 var shouldPrepareBinanceMarketContextForRun = (params) => {
   if (params.universe === "tradfi") return false;
   if (params.mode === "backtest") {
+    if (!params.aiEnabled && !params.mlEnabled) return false;
     return shouldBackfillBinanceMarketContextForBacktest({
       aiEnabled: Boolean(params.aiEnabled),
       cacheOnly: params.cacheOnly,
@@ -4938,6 +4948,7 @@ var shouldPrepareBinanceMarketContextForRun = (params) => {
 var shouldPrepareCoinMarketCapContextForRun = (params) => {
   if (params.universe === "tradfi") return false;
   if (params.mode === "backtest") {
+    if (!params.aiEnabled && !params.mlEnabled) return false;
     return shouldBackfillCoinMarketCapContextForBacktest({
       aiEnabled: Boolean(params.aiEnabled),
       cacheOnly: params.cacheOnly,
@@ -4953,10 +4964,8 @@ var shouldPrepareCoinMarketCapContextForRun = (params) => {
     cacheOnly: params.cacheOnly
   });
 };
-var shouldPrepareHyperliquidWhaleContextForRun = (params) => {
-  const strategyRequiresContext = params.strategyNames?.includes(
-    "HyperliquidConsensus"
-  );
+var shouldPrepareHyperliquidWhaleContextForRun = (params, coreContextSources = []) => {
+  const strategyRequiresContext = coreContextSources.includes("hyperliquidWhales");
   if (params.universe === "tradfi" || params.mode === "signals" || params.cacheOnly || !params.aiEnabled && !params.mlEnabled && !strategyRequiresContext) {
     return false;
   }
@@ -4967,6 +4976,64 @@ var shouldPrepareHyperliquidWhaleContextForRun = (params) => {
   if (strategyRequiresContext) return true;
   return ["1", "true", "yes", "on"].includes(configured);
 };
+var resolveCoreContextSources = async (params) => {
+  const strategyNames = [...new Set(params.strategyNames ?? [])];
+  if (!strategyNames.length) return [];
+  await (0, import_registry.ensureStrategyPluginsLoaded)(params.projectRoot);
+  return [
+    ...new Set(
+      strategyNames.flatMap(
+        (strategyName) => (0, import_registry.getStrategyManifest)(strategyName, params.projectRoot)?.contextRequirements?.core ?? []
+      )
+    )
+  ];
+};
+var resolveMarketContextRunRequirements = async (params) => {
+  const coreContextSources = await resolveCoreContextSources(params);
+  const paramsWithCoreDemand = (source) => coreContextSources.includes(source) ? { ...params, aiEnabled: true } : params;
+  const isCrypto = params.universe !== "tradfi";
+  const capturesPayload = Boolean(params.aiEnabled || params.mlEnabled);
+  const runtimeReadsContext = params.mode !== "backtest";
+  const reasonsFor = (source) => uniqueReasons([
+    ...coreContextSources.includes(source) ? ["core"] : [],
+    ...params.aiEnabled ? ["ai"] : [],
+    ...params.mlEnabled ? ["ml"] : [],
+    ...runtimeReadsContext ? ["runtime"] : []
+  ]);
+  const readsStandardContext = isCrypto && (capturesPayload || runtimeReadsContext);
+  const readsHyperliquid = isCrypto && (readsStandardContext || coreContextSources.includes("hyperliquidWhales"));
+  return {
+    binance: {
+      read: readsStandardContext || coreContextSources.includes("binance"),
+      backfill: shouldPrepareBinanceMarketContextForRun(
+        paramsWithCoreDemand("binance")
+      ),
+      requiredBy: reasonsFor("binance")
+    },
+    coinmarketcap: {
+      read: readsStandardContext || coreContextSources.includes("coinmarketcap"),
+      backfill: shouldPrepareCoinMarketCapContextForRun(
+        paramsWithCoreDemand("coinmarketcap")
+      ),
+      requiredBy: reasonsFor("coinmarketcap")
+    },
+    derivatives: {
+      read: readsStandardContext || coreContextSources.includes("derivatives"),
+      backfill: shouldPrepareDerivativesContextForRun(
+        paramsWithCoreDemand("derivatives")
+      ),
+      requiredBy: reasonsFor("derivatives")
+    },
+    hyperliquidWhales: {
+      read: readsHyperliquid,
+      backfill: shouldPrepareHyperliquidWhaleContextForRun(
+        params,
+        coreContextSources
+      ),
+      requiredBy: reasonsFor("hyperliquidWhales")
+    }
+  };
+};
 var resolveCoinMarketCapBackfillForMode = (mode) => mode === "backtest" ? backfillCoinMarketCapContextForBacktest : mode === "signals" ? backfillCoinMarketCapContextForSignals : backfillCoinMarketCapContextForReplay;
 var buildCoinMarketCapBackfillParams = (params) => ({
   userName: params.userName,
@@ -4995,7 +5062,15 @@ var prepareMarketContextForRun = async (params) => {
     console.log(import_chalk4.default.gray(message));
   });
   const timeOperation2 = (label, operation) => timeOperation(label, operation, log);
-  if (shouldPrepareDerivativesContextForRun(params)) {
+  const requirements = await resolveMarketContextRunRequirements(params);
+  const readableSources = Object.entries(requirements).filter(([, requirement]) => requirement.read).map(([source]) => source);
+  if (readableSources.length) {
+    await timeOperation2(
+      "market context schema ensure",
+      () => (0, import_timescale5.ensureMarketContextSchemas)(readableSources)
+    );
+  }
+  if (requirements.derivatives.backfill) {
     await timeOperation2(
       "derivatives context backfill",
       () => (params.mode === "signals" ? backfillDerivativesContextForSignals : backfillDerivativesContextForBacktest)(
@@ -5003,7 +5078,7 @@ var prepareMarketContextForRun = async (params) => {
       )
     );
   }
-  if (shouldPrepareHyperliquidWhaleContextForRun(params)) {
+  if (requirements.hyperliquidWhales.backfill) {
     await timeOperation2(
       "hyperliquid whale context backfill",
       () => backfillHyperliquidWhaleContext({
@@ -5015,13 +5090,13 @@ var prepareMarketContextForRun = async (params) => {
       })
     );
   }
-  if (shouldPrepareBinanceMarketContextForRun(params)) {
+  if (requirements.binance.backfill) {
     await timeOperation2("binance market context backfill", () => {
       const backfill = params.mode === "backtest" ? backfillBinanceMarketContextForBacktest : params.mode === "signals" ? backfillBinanceMarketContextForSignals : backfillBinanceMarketContextForReplay;
       return backfill(buildBinanceMarketBackfillParams(params));
     });
   }
-  if (shouldPrepareCoinMarketCapContextForRun(params)) {
+  if (requirements.coinmarketcap.backfill) {
     await timeOperation2(
       "coinmarketcap historical context backfill",
       () => resolveCoinMarketCapBackfillForMode(params.mode)(
@@ -5029,10 +5104,12 @@ var prepareMarketContextForRun = async (params) => {
       )
     );
   }
+  return requirements;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   prepareMarketContextForRun,
+  resolveMarketContextRunRequirements,
   shouldPrepareBinanceMarketContextForRun,
   shouldPrepareCoinMarketCapContextForRun,
   shouldPrepareDerivativesContextForRun,

package/dist/lib/researchAgent.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/lib/researchAgent.ts
@@ -39,24 +29,14 @@ __export(researchAgent_exports, {
   buildResearchAgentPrBody: () => buildResearchAgentPrBody,
   buildResearchAgentPrTitle: () => buildResearchAgentPrTitle,
   getResearchAgentAllowedPathPrefixes: () => getResearchAgentAllowedPathPrefixes,
-  getResearchAgentNotePath: () => getResearchAgentNotePath,
   normalizeDiffOutput: () => normalizeDiffOutput,
   parseChangedFilesFromDiff: () => parseChangedFilesFromDiff,
-  parseGithubRepositoryFromRemote: () => parseGithubRepositoryFromRemote,
-  toUpperSnakeCase: () => toUpperSnakeCase
+  parseGithubRepositoryFromRemote: () => parseGithubRepositoryFromRemote
 });
 module.exports = __toCommonJS(researchAgent_exports);
-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();
@@ -64,13 +44,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();
@@ -187,9 +162,7 @@ ${diffText}`)) {
   buildResearchAgentPrBody,
   buildResearchAgentPrTitle,
   getResearchAgentAllowedPathPrefixes,
-  getResearchAgentNotePath,
   normalizeDiffOutput,
   parseChangedFilesFromDiff,
-  parseGithubRepositoryFromRemote,
-  toUpperSnakeCase
+  parseGithubRepositoryFromRemote
 });

package/dist/lib/runtimeDebugEvidence.js

@@ -25,6 +25,7 @@ __export(runtimeDebugEvidence_exports, {
   buildRuntimeDebugEvaluationId: () => buildRuntimeDebugEvaluationId,
   buildRuntimeDebugReportAttachment: () => buildRuntimeDebugReportAttachment,
   buildRuntimeDebugReportPayload: () => buildRuntimeDebugReportPayload,
+  buildRuntimeEvidenceReportPayload: () => buildRuntimeEvidenceReportPayload,
   collectRuntimeDebugEvidence: () => collectRuntimeDebugEvidence
 });
 module.exports = __toCommonJS(runtimeDebugEvidence_exports);
@@ -122,6 +123,29 @@ var loadRuntimeTrades = async (userName, {
   const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
   return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
 };
+var loadRuntimeClosedTrades = async (userName, {
+  startTime,
+  endTime
+}) => {
+  const dayKeys = (0, import_time.getRuntimeStorageDayKeys)(startTime, endTime);
+  const trades = (await Promise.all(
+    dayKeys.map(
+      (dayKey) => (0, import_redis.getHashJsonValues)(
+        import_redis.redisKeys.runtimeClosedTradeBucket(userName, dayKey)
+      )
+    )
+  )).flat();
+  const deduped = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    if (!isRuntimeTradeRecord(trade) || trade.status !== "closed" || !Number.isFinite(trade.exitTimestamp) || trade.exitTimestamp < startTime || trade.exitTimestamp >= endTime) {
+      continue;
+    }
+    deduped.set(trade.orderId, trade);
+  }
+  return [...deduped.values()].sort(
+    (left, right) => left.exitTimestamp - right.exitTimestamp
+  );
+};
 
 // src/lib/runtimeSignalsLoader.ts
 var import_redis2 = require("@tradejs/infra/redis");
@@ -319,13 +343,30 @@ var collectRuntimeDebugEvidence = async ({
 }) => {
   const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
   const dayKeySet = new Set(dayKeys);
-  const [trades, signals, evaluations, evaluationStatsBuckets, configs] = await Promise.all([
+  const [
+    entryTrades,
+    closedTrades,
+    signals,
+    evaluations,
+    evaluationStatsBuckets,
+    configs
+  ] = await Promise.all([
     loadRuntimeTrades(userName, { startTime, endTime }),
+    loadRuntimeClosedTrades(userName, { startTime, endTime }),
     loadRuntimeSignals(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluations(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluationStatsBuckets(userName),
     loadRuntimeStrategyConfigs(userName)
   ]);
+  const tradesByOrderId = new Map(
+    entryTrades.map((trade) => [trade.orderId, trade])
+  );
+  for (const trade of closedTrades) {
+    tradesByOrderId.set(trade.orderId, trade);
+  }
+  const trades = [...tradesByOrderId.values()].sort(
+    (left, right) => left.entryTimestamp - right.entryTimestamp
+  );
   const filteredStats = evaluationStatsBuckets.filter(
     (entry) => dayKeySet.has(entry.dayKey) && (!strategies?.length || strategies.includes(entry.strategy))
   );
@@ -502,6 +543,39 @@ var buildRuntimeDebugReportPayload = async ({
     strategyConfigs: strategyConfigs ?? []
   };
 };
+var buildRuntimeEvidenceReportPayload = ({
+  userName,
+  startTime,
+  endTime,
+  signals,
+  evaluations,
+  trades,
+  strategyConfigs,
+  evaluationStatsBuckets
+}) => ({
+  reportType: "runtime-daily-evidence",
+  generatedAt: Date.now(),
+  userName,
+  window: {
+    startTime,
+    endTime,
+    startMsk: formatRuntimeDebugDateTime(startTime),
+    endMsk: formatRuntimeDebugDateTime(endTime),
+    dayKeys: (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime)
+  },
+  counts: {
+    trades: trades.length,
+    signals: signals.length,
+    evaluations: evaluations.length,
+    evaluationStatsBuckets: evaluationStatsBuckets?.length ?? 0,
+    strategyConfigs: strategyConfigs?.length ?? 0
+  },
+  trades: trades.map((trade) => ({ trade })),
+  signals: signals.map((signal) => ({ signal })),
+  evaluations: evaluations.map((evaluation) => ({ evaluation })),
+  evaluationStatsBuckets: evaluationStatsBuckets ?? [],
+  strategyConfigs: strategyConfigs ?? []
+});
 var buildRuntimeDebugReportAttachment = async (params) => {
   const payload = await buildRuntimeDebugReportPayload(params);
   const dayKey = formatRuntimeDebugIsoDayKey(params.endTime);
@@ -523,5 +597,6 @@ var buildRuntimeDebugReportAttachment = async (params) => {
   buildRuntimeDebugEvaluationId,
   buildRuntimeDebugReportAttachment,
   buildRuntimeDebugReportPayload,
+  buildRuntimeEvidenceReportPayload,
   collectRuntimeDebugEvidence
 });

package/dist/lib/runtimeEvidenceArtifacts.js

@@ -0,0 +1,255 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/runtimeEvidenceArtifacts.ts
+var runtimeEvidenceArtifacts_exports = {};
+__export(runtimeEvidenceArtifacts_exports, {
+  RUNTIME_EVIDENCE_COMPLETE_FILE: () => RUNTIME_EVIDENCE_COMPLETE_FILE,
+  RUNTIME_EVIDENCE_MANIFEST_FILE: () => RUNTIME_EVIDENCE_MANIFEST_FILE,
+  RUNTIME_EVIDENCE_PAYLOAD_FILE: () => RUNTIME_EVIDENCE_PAYLOAD_FILE,
+  discoverRuntimeEvidenceBundles: () => discoverRuntimeEvidenceBundles,
+  publishRuntimeEvidenceBundle: () => publishRuntimeEvidenceBundle,
+  verifyRuntimeEvidenceBundle: () => verifyRuntimeEvidenceBundle
+});
+module.exports = __toCommonJS(runtimeEvidenceArtifacts_exports);
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var RUNTIME_EVIDENCE_MANIFEST_FILE = "manifest.json";
+var RUNTIME_EVIDENCE_PAYLOAD_FILE = "runtime-evidence.json";
+var RUNTIME_EVIDENCE_COMPLETE_FILE = ".complete";
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var sha256 = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
+var isExistingDestinationError = (error) => {
+  const code = error.code;
+  return code === "EEXIST" || code === "ENOTEMPTY";
+};
+var safeSegment = (value, fallback) => {
+  const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+  return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
+};
+var compactTimestamp = (timestamp) => new Date(timestamp).toISOString().replace(/[-:]/g, "").replace(/\.000Z$/, "Z");
+var dateParts = (timestamp) => {
+  const date = new Date(timestamp);
+  return [
+    String(date.getUTCFullYear()),
+    String(date.getUTCMonth() + 1).padStart(2, "0"),
+    String(date.getUTCDate()).padStart(2, "0")
+  ];
+};
+var assertFiniteTimestamp = (value, label) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`Invalid runtime evidence ${label}`);
+  }
+  return value;
+};
+var parseManifest = (value) => {
+  const manifest = asRecord(value);
+  const window = asRecord(manifest?.window);
+  const payload = asRecord(manifest?.payload);
+  const counts = asRecord(manifest?.counts);
+  if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-evidence" || typeof manifest.artifactId !== "string" || typeof manifest.deploymentId !== "string" || typeof manifest.userName !== "string" || typeof manifest.createdAt !== "number" || payload?.file !== RUNTIME_EVIDENCE_PAYLOAD_FILE || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number" || !Array.isArray(manifest.lineageKeys)) {
+    throw new Error("Invalid runtime evidence manifest");
+  }
+  return {
+    schemaVersion: 1,
+    artifactId: manifest.artifactId,
+    reportType: "runtime-evidence",
+    deploymentId: manifest.deploymentId,
+    userName: manifest.userName,
+    createdAt: manifest.createdAt,
+    window: {
+      startTime: assertFiniteTimestamp(window?.startTime, "window.startTime"),
+      endTime: assertFiniteTimestamp(window?.endTime, "window.endTime")
+    },
+    payload: {
+      file: RUNTIME_EVIDENCE_PAYLOAD_FILE,
+      sha256: payload.sha256,
+      bytes: payload.bytes
+    },
+    counts: Object.fromEntries(
+      Object.entries(counts ?? {}).filter(
+        (entry) => typeof entry[1] === "number" && Number.isFinite(entry[1])
+      )
+    ),
+    lineageKeys: manifest.lineageKeys.filter(
+      (value2) => typeof value2 === "string" && value2.length > 0
+    )
+  };
+};
+var publishRuntimeEvidenceBundle = async ({
+  publishRoot,
+  deploymentId,
+  userName,
+  startTime,
+  endTime,
+  artifact,
+  counts,
+  lineageKeys
+}) => {
+  const payload = `${JSON.stringify(artifact, null, 2)}
+`;
+  const payloadSha256 = sha256(payload);
+  const safeDeploymentId = safeSegment(deploymentId, "default");
+  const artifactId = [
+    compactTimestamp(startTime),
+    compactTimestamp(endTime),
+    payloadSha256.slice(0, 16)
+  ].join("_");
+  const createdAt = Date.now();
+  const manifest = {
+    schemaVersion: 1,
+    artifactId,
+    reportType: "runtime-evidence",
+    deploymentId: safeDeploymentId,
+    userName,
+    createdAt,
+    window: { startTime, endTime },
+    payload: {
+      file: RUNTIME_EVIDENCE_PAYLOAD_FILE,
+      sha256: payloadSha256,
+      bytes: Buffer.byteLength(payload)
+    },
+    counts,
+    lineageKeys: [...new Set(lineageKeys)].sort()
+  };
+  const incomingRoot = import_node_path.default.join(publishRoot, "incoming");
+  const readyRoot = import_node_path.default.join(
+    publishRoot,
+    "ready",
+    safeDeploymentId,
+    ...dateParts(endTime)
+  );
+  const bundleDir = import_node_path.default.join(readyRoot, artifactId);
+  const temporaryDir = import_node_path.default.join(
+    incomingRoot,
+    `${artifactId}.tmp-${(0, import_node_crypto.randomUUID)()}`
+  );
+  await import_promises.default.mkdir(temporaryDir, { recursive: true });
+  try {
+    await Promise.all([
+      import_promises.default.writeFile(
+        import_node_path.default.join(temporaryDir, RUNTIME_EVIDENCE_PAYLOAD_FILE),
+        payload,
+        "utf8"
+      ),
+      import_promises.default.writeFile(
+        import_node_path.default.join(temporaryDir, RUNTIME_EVIDENCE_MANIFEST_FILE),
+        `${JSON.stringify(manifest, null, 2)}
+`,
+        "utf8"
+      )
+    ]);
+    await import_promises.default.writeFile(
+      import_node_path.default.join(temporaryDir, RUNTIME_EVIDENCE_COMPLETE_FILE),
+      `${artifactId}
+`,
+      "utf8"
+    );
+    await import_promises.default.mkdir(readyRoot, { recursive: true });
+    try {
+      await import_promises.default.rename(temporaryDir, bundleDir);
+    } catch (error) {
+      if (!isExistingDestinationError(error)) {
+        throw error;
+      }
+      await import_promises.default.rm(temporaryDir, { recursive: true, force: true });
+    }
+  } catch (error) {
+    await import_promises.default.rm(temporaryDir, { recursive: true, force: true });
+    throw error;
+  }
+  return verifyRuntimeEvidenceBundle(bundleDir);
+};
+var verifyRuntimeEvidenceBundle = async (bundleDir) => {
+  const manifestPath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_MANIFEST_FILE);
+  const payloadPath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_PAYLOAD_FILE);
+  const completePath = import_node_path.default.join(bundleDir, RUNTIME_EVIDENCE_COMPLETE_FILE);
+  const [manifestText, payload, completeText] = await Promise.all([
+    import_promises.default.readFile(manifestPath, "utf8"),
+    import_promises.default.readFile(payloadPath),
+    import_promises.default.readFile(completePath, "utf8")
+  ]);
+  const manifest = parseManifest(JSON.parse(manifestText));
+  if (completeText.trim() !== manifest.artifactId) {
+    throw new Error(`Invalid completion marker in ${bundleDir}`);
+  }
+  if (payload.byteLength !== manifest.payload.bytes) {
+    throw new Error(`Runtime evidence size mismatch in ${bundleDir}`);
+  }
+  if (sha256(payload) !== manifest.payload.sha256) {
+    throw new Error(`Runtime evidence checksum mismatch in ${bundleDir}`);
+  }
+  const artifact = asRecord(JSON.parse(payload.toString("utf8")));
+  const artifactWindow = asRecord(artifact?.window);
+  if (artifact?.reportType !== "runtime-evidence" || artifactWindow?.startTime !== manifest.window.startTime || artifactWindow.endTime !== manifest.window.endTime) {
+    throw new Error(`Runtime evidence payload mismatch in ${bundleDir}`);
+  }
+  return {
+    bundleDir,
+    manifestPath,
+    payloadPath,
+    manifest,
+    artifact
+  };
+};
+var discoverRuntimeEvidenceBundles = async (rootDir) => {
+  const bundles = [];
+  const visit = async (directory, depth) => {
+    if (depth > 8) return;
+    let entries;
+    try {
+      entries = await import_promises.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_EVIDENCE_MANIFEST_FILE) && names.has(RUNTIME_EVIDENCE_PAYLOAD_FILE) && names.has(RUNTIME_EVIDENCE_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_path.default.join(directory, entry.name), depth + 1))
+    );
+  };
+  await visit(rootDir, 0);
+  return bundles.sort();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RUNTIME_EVIDENCE_COMPLETE_FILE,
+  RUNTIME_EVIDENCE_MANIFEST_FILE,
+  RUNTIME_EVIDENCE_PAYLOAD_FILE,
+  discoverRuntimeEvidenceBundles,
+  publishRuntimeEvidenceBundle,
+  verifyRuntimeEvidenceBundle
+});