@tradejs/cli 3.1.29-beta.275 → 3.1.29-beta.277

package/dist/cli.js

@@ -2278,9 +2278,9 @@ var init_features = __esm({
       "targetsymbol",
       "universe"
     ]);
-    normalizeFeaturePath = (path44) => (Array.isArray(path44) ? path44 : path44.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
-    classifyAiPocketCoverageFeaturePath = (path44) => {
-      const segments = normalizeFeaturePath(path44);
+    normalizeFeaturePath = (path47) => (Array.isArray(path47) ? path47 : path47.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
+    classifyAiPocketCoverageFeaturePath = (path47) => {
+      const segments = normalizeFeaturePath(path47);
       const normalizedPath = segments.join(".");
       if (segments.some(
         (segment) => segment.includes("cmc") || segment.includes("coinmarketcap")
@@ -2454,8 +2454,8 @@ var init_features = __esm({
       "volumeusd",
       "vwap"
     ]);
-    classifyAiPocketFeaturePath = (path44) => {
-      const segments = (Array.isArray(path44) ? path44 : path44.split(".")).filter(
+    classifyAiPocketFeaturePath = (path47) => {
+      const segments = (Array.isArray(path47) ? path47 : path47.split(".")).filter(
         Boolean
       );
       const normalized = segments.map((segment) => segment.toLowerCase());
@@ -2772,11 +2772,11 @@ var init_features = __esm({
         excludeFeaturePattern.source,
         excludeFeaturePattern.flags.replace(/[gy]/g, "")
       ) : void 0;
-      const isOperatorExcluded = (path44) => {
-        if (!exclusion?.test(path44)) {
+      const isOperatorExcluded = (path47) => {
+        if (!exclusion?.test(path47)) {
           return false;
         }
-        onFeatureExcluded?.({ path: path44, classification: "operator-excluded" });
+        onFeatureExcluded?.({ path: path47, classification: "operator-excluded" });
         return true;
       };
       const signal = payload.signal ?? {};
@@ -11317,27 +11317,27 @@ var init_coinMarketCapContextBackfill = __esm({
       totalCredits: 0,
       byPath: /* @__PURE__ */ new Map()
     });
-    getCoinMarketCapPathLabel = (path44) => {
-      if (path44.includes("global-metrics")) return "global";
-      if (path44.includes("cryptocurrency/quotes")) return "reference";
-      if (path44.includes("exchange/quotes")) return "exchangeLiquidity";
-      if (path44.includes("fear-and-greed")) return "fearGreed";
-      if (path44.includes("cmc100")) return "cmc100";
-      if (path44.includes("cmc20")) return "cmc20";
-      return path44;
-    };
-    recordCoinMarketCapFetchStats = (stats, path44, creditCount) => {
+    getCoinMarketCapPathLabel = (path47) => {
+      if (path47.includes("global-metrics")) return "global";
+      if (path47.includes("cryptocurrency/quotes")) return "reference";
+      if (path47.includes("exchange/quotes")) return "exchangeLiquidity";
+      if (path47.includes("fear-and-greed")) return "fearGreed";
+      if (path47.includes("cmc100")) return "cmc100";
+      if (path47.includes("cmc20")) return "cmc20";
+      return path47;
+    };
+    recordCoinMarketCapFetchStats = (stats, path47, creditCount) => {
       if (!stats) return;
-      const existing = stats.byPath.get(path44) ?? { requests: 0, credits: 0 };
+      const existing = stats.byPath.get(path47) ?? { requests: 0, credits: 0 };
       existing.requests += 1;
       existing.credits += creditCount ?? 0;
       stats.requests += 1;
       stats.totalCredits += creditCount ?? 0;
-      stats.byPath.set(path44, existing);
+      stats.byPath.set(path47, existing);
     };
     formatCoinMarketCapFetchStats = (stats) => {
       const byPath = [...stats.byPath.entries()].map(
-        ([path44, item]) => `${getCoinMarketCapPathLabel(path44)}=${item.requests}req/${item.credits}cr`
+        ([path47, item]) => `${getCoinMarketCapPathLabel(path47)}=${item.requests}req/${item.credits}cr`
       ).join(" ");
       return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
     };
@@ -24567,6 +24567,116 @@ var init_marketWs = __esm({
   }
 });
 
+// src/lib/runtimeEvidenceProducer.ts
+var runtimeEvidenceProducer_exports = {};
+var init_runtimeEvidenceProducer = __esm({
+  "src/lib/runtimeEvidenceProducer.ts"() {
+    "use strict";
+    __reExport(runtimeEvidenceProducer_exports, require("@tradejs/node/diagnostics"));
+  }
+});
+
+// src/lib/runtimeEvidenceArtifacts.ts
+var runtimeEvidenceArtifacts_exports = {};
+var init_runtimeEvidenceArtifacts = __esm({
+  "src/lib/runtimeEvidenceArtifacts.ts"() {
+    "use strict";
+    __reExport(runtimeEvidenceArtifacts_exports, require("@tradejs/node/diagnostics"));
+  }
+});
+
+// src/lib/mcpReplayProcess.ts
+var import_node_path14, buildMcpReplayProcess;
+var init_mcpReplayProcess = __esm({
+  "src/lib/mcpReplayProcess.ts"() {
+    "use strict";
+    import_node_path14 = __toESM(require("path"));
+    init_runtimeEvidenceProducer();
+    init_runtimeEvidenceArtifacts();
+    buildMcpReplayProcess = async ({
+      evidencePath,
+      outDir,
+      runId,
+      projectRoot: projectRoot18,
+      env
+    }) => {
+      if (!/^[a-zA-Z0-9_-]{1,100}$/.test(runId))
+        throw new Error("Invalid replay container run id");
+      const bundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(import_node_path14.default.dirname(evidencePath));
+      if (import_node_path14.default.resolve(evidencePath) !== import_node_path14.default.resolve(bundle.payloadPath))
+        throw new Error("Replay requires the verified bundle payload");
+      const producer = (0, runtimeEvidenceProducer_exports.parseRuntimeEvidenceProducer)(bundle.artifact.producer);
+      if (!env.MCP_REPLAY_HOST_PROJECT_ROOT || !env.MCP_REPLAY_NETWORK || !env.MCP_REPLAY_IMAGE_REPOSITORY)
+        throw new Error(
+          "Image-bound replay requires MCP_REPLAY_HOST_PROJECT_ROOT MCP_REPLAY_NETWORK and MCP_REPLAY_IMAGE_REPOSITORY"
+        );
+      const hostPath = (file) => {
+        const relative = import_node_path14.default.relative(projectRoot18, file);
+        if (relative.startsWith("..") || import_node_path14.default.isAbsolute(relative))
+          throw new Error("Replay mounts must be inside the Project");
+        return import_node_path14.default.join(env.MCP_REPLAY_HOST_PROJECT_ROOT, relative);
+      };
+      const args39 = [
+        "run",
+        "--rm",
+        "--name",
+        `tradejs-replay-${runId}`,
+        "--memory=1536m",
+        "--cpus=1",
+        "--pids-limit=512",
+        "--read-only",
+        "--cap-drop=ALL",
+        "--security-opt=no-new-privileges",
+        "--network",
+        env.MCP_REPLAY_NETWORK,
+        "--tmpfs",
+        "/tmp",
+        "--tmpfs",
+        "/app/data",
+        "--entrypoint",
+        "/app/node_modules/.bin/tradejs",
+        "--mount",
+        `type=bind,src=${hostPath(import_node_path14.default.dirname(evidencePath))},dst=/evidence,readonly`,
+        "--mount",
+        `type=bind,src=${hostPath(outDir)},dst=/replay-output`
+      ];
+      const safeEnv = {
+        PROJECT_CWD: "/app",
+        DOTENV_CONFIG_PATH: "/dev/null",
+        TRADEJS_PROJECT_SHA: producer.projectSha,
+        TRADEJS_PROJECT_IMAGE_DIGEST: producer.imageDigest,
+        NODE_OPTIONS: "--max-old-space-size=1024",
+        MAKE_ORDERS: "false",
+        TRADEJS_EXTERNAL_ORDER_PLACEMENT: "false",
+        AI_ENABLED: "false",
+        ML_ENABLED: "false",
+        RUNTIME_FEEDBACK_ISOLATED_REDIS: "true",
+        REDIS_HOST: env.MCP_REPLAY_REDIS_HOST,
+        REDIS_PORT: "6379",
+        REDIS_DB: "0",
+        PGOPTIONS: "-c default_transaction_read_only=on",
+        TRADEJS_TIMESCALE_READ_ONLY: "true"
+      };
+      for (const name of ["PG_HOST", "PG_PORT", "PG_USER", "PG_DATABASE", "PG_DB"])
+        if (env[name]) safeEnv[name] = env[name];
+      for (const [name, value] of Object.entries(safeEnv))
+        if (value !== void 0) args39.push("--env", `${name}=${value}`);
+      if (env.PG_PASSWORD) args39.push("--env", "PG_PASSWORD");
+      args39.push(
+        `${env.MCP_REPLAY_IMAGE_REPOSITORY}@${producer.imageDigest}`,
+        "runtime-feedback-replay",
+        "--runtimeEvidence",
+        `/evidence/${import_node_path14.default.basename(evidencePath)}`,
+        "--outDir",
+        "/replay-output",
+        "--runId",
+        runId
+      );
+      return { executable: "docker", args: args39 };
+    };
+  }
+});
+
 // src/scripts/mcpWorker.ts
 var mcpWorker_exports = {};
 __export(mcpWorker_exports, {
@@ -24581,6 +24691,7 @@ var init_mcpWorker = __esm({
     import_promises17 = require("fs/promises");
     import_redis15 = require("@tradejs/infra/redis");
     import_mcp = require("@tradejs/node/mcp");
+    init_mcpReplayProcess();
     pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
     leaseKey = "worker:lease";
     LEASE_SECONDS = 15;
@@ -24607,7 +24718,9 @@ var init_mcpWorker = __esm({
       const heartbeatValue = () => ({
         observedAt: Date.now(),
         packageManifestSha256: manifestHash,
-        replayAvailable: Boolean(process.env.MCP_REPLAY_REDIS_HOST)
+        replayAvailable: Boolean(
+          process.env.MCP_REPLAY_REDIS_HOST && process.env.MCP_REPLAY_HOST_PROJECT_ROOT && process.env.MCP_REPLAY_NETWORK && process.env.MCP_REPLAY_IMAGE_REPOSITORY
+        )
       });
       const stop = () => {
         stopping = true;
@@ -24733,7 +24846,37 @@ var init_mcpWorker = __esm({
               TRADEJS_TIMESCALE_READ_ONLY: "true"
             });
           }
-          child = (0, import_node_child_process4.spawn)(process.execPath, [process.argv[1], ...started.args], {
+          let command = {
+            executable: process.execPath,
+            args: [process.argv[1], ...started.args]
+          };
+          try {
+            if (started.kind === "runtime-feedback-replay")
+              command = await buildMcpReplayProcess({
+                evidencePath: String(started.request.verifiedEvidencePath),
+                outDir: (0, import_mcp.mcpJobDirectory)(started),
+                runId: started.id,
+                projectRoot: process.env.PROJECT_CWD || process.cwd(),
+                env: process.env
+              });
+          } catch (error) {
+            await import_redis15.mcpStorage.compare(
+              jobKey,
+              started,
+              {
+                ...started,
+                status: "failed",
+                finishedAt: Date.now(),
+                updatedAt: Date.now(),
+                error: error instanceof Error ? error.message : "Replay preparation failed"
+              },
+              import_mcp.MCP_JOB_TTL
+            );
+            continue;
+          }
+          if (started.kind === "runtime-feedback-replay" && process.env.PG_PASSWORD)
+            jobEnv.PG_PASSWORD = process.env.PG_PASSWORD;
+          child = (0, import_node_child_process4.spawn)(command.executable, command.args, {
             cwd: process.env.PROJECT_CWD || process.cwd(),
             env: jobEnv,
             detached: process.platform !== "win32",
@@ -24787,6 +24930,20 @@ var init_mcpWorker = __esm({
             );
             currentChild.once("exit", (code) => resolve({ code }));
           });
+          if (started.kind === "runtime-feedback-replay") {
+            await new Promise((resolve) => {
+              const cleanup = (0, import_node_child_process4.spawn)(
+                "docker",
+                ["rm", "--force", `tradejs-replay-${started.id}`],
+                {
+                  stdio: "ignore",
+                  timeout: 1e4
+                }
+              );
+              cleanup.once("error", () => resolve());
+              cleanup.once("close", () => resolve());
+            });
+          }
           clearTimeout(timeout);
           clearInterval(monitor);
           child = void 0;
@@ -26961,7 +27118,7 @@ __export(researchAuto_exports, {
   toStrategyConfigGrid: () => toStrategyConfigGrid2,
   trimTextTail: () => trimTextTail2
 });
-var import_args25, import_chalk40, import_node_child_process5, import_promises21, import_node_os2, import_node_path14, import_constants18, import_ai8, import_logger6, import_redis16, import_registry4, flags23, projectRoot8, dotenvPath, getResearchAutoLockPath, readResearchAutoLock, isProcessAlive, acquireResearchAutoLock, releaseResearchAutoLock, resolvePositiveInteger, resolveHeapMbFromEnv, buildNodeOptions, RESEARCH_AUTO_PARENT_HEAP_MB, RESEARCH_AUTO_BACKTEST_PARENT_HEAP_MB, RESEARCH_AUTO_AI_TRAIN_PARENT_HEAP_MB, RESEARCH_AUTO_AGENT_PARENT_HEAP_MB, trimTextTail2, escapeHtml3, createEmptySteps, saveRun, listMergedFiles3, getBacktestResultsPrefix, listRuntimeStrategyNames, toStrategyConfigGrid2, formatMskDateTime, buildTelegramReport, runCliCommand, resolveTarget, parseJsonOutput, logResearch, executeNonBlockingStep, main33;
+var import_args25, import_chalk40, import_node_child_process5, import_promises21, import_node_os2, import_node_path15, import_constants18, import_ai8, import_logger6, import_redis16, import_registry4, flags23, projectRoot8, dotenvPath, getResearchAutoLockPath, readResearchAutoLock, isProcessAlive, acquireResearchAutoLock, releaseResearchAutoLock, resolvePositiveInteger, resolveHeapMbFromEnv, buildNodeOptions, RESEARCH_AUTO_PARENT_HEAP_MB, RESEARCH_AUTO_BACKTEST_PARENT_HEAP_MB, RESEARCH_AUTO_AI_TRAIN_PARENT_HEAP_MB, RESEARCH_AUTO_AGENT_PARENT_HEAP_MB, trimTextTail2, escapeHtml3, createEmptySteps, saveRun, listMergedFiles3, getBacktestResultsPrefix, listRuntimeStrategyNames, toStrategyConfigGrid2, formatMskDateTime, buildTelegramReport, runCliCommand, resolveTarget, parseJsonOutput, logResearch, executeNonBlockingStep, main33;
 var init_researchAuto = __esm({
   "src/scripts/researchAuto.ts"() {
     "use strict";
@@ -26970,7 +27127,7 @@ var init_researchAuto = __esm({
     import_node_child_process5 = require("child_process");
     import_promises21 = __toESM(require("fs/promises"));
     import_node_os2 = __toESM(require("os"));
-    import_node_path14 = __toESM(require("path"));
+    import_node_path15 = __toESM(require("path"));
     import_constants18 = require("@tradejs/core/constants");
     import_ai8 = require("@tradejs/infra/ai");
     import_logger6 = require("@tradejs/infra/logger");
@@ -27004,9 +27161,9 @@ var init_researchAuto = __esm({
     flags23 = import_args25.default.parse(process.argv);
     ({ projectRoot: projectRoot8 } = resolveResearchRoots());
     dotenvPath = String(
-      process.env.DOTENV_CONFIG_PATH || import_node_path14.default.join(projectRoot8, ".env")
-    ).trim() || import_node_path14.default.join(projectRoot8, ".env");
-    getResearchAutoLockPath = (userName3) => import_node_path14.default.join(
+      process.env.DOTENV_CONFIG_PATH || import_node_path15.default.join(projectRoot8, ".env")
+    ).trim() || import_node_path15.default.join(projectRoot8, ".env");
+    getResearchAutoLockPath = (userName3) => import_node_path15.default.join(
       projectRoot8,
       "data",
       "cache",
@@ -27050,7 +27207,7 @@ var init_researchAuto = __esm({
         startedAt,
         argv: [...process.argv]
       };
-      await import_promises21.default.mkdir(import_node_path14.default.dirname(lockPath), { recursive: true });
+      await import_promises21.default.mkdir(import_node_path15.default.dirname(lockPath), { recursive: true });
       const writeLock = async () => {
         await import_promises21.default.writeFile(lockPath, JSON.stringify(nextLock, null, 2), {
           flag: "wx"
@@ -27187,7 +27344,7 @@ var init_researchAuto = __esm({
       try {
         const entries = await import_promises21.default.readdir(outDir);
         const prefix = `ai-dataset-${(0, import_ai8.toFileToken)(strategyName)}-merged-`;
-        return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).sort().map((name) => import_node_path14.default.join(outDir, name));
+        return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).sort().map((name) => import_node_path15.default.join(outDir, name));
       } catch {
         return [];
       }
@@ -27321,7 +27478,7 @@ var init_researchAuto = __esm({
       return new Promise((resolve, reject) => {
         const child = (0, import_node_child_process5.spawn)(
           process.execPath,
-          [import_node_path14.default.resolve(process.argv[1]), params.command, ...params.args],
+          [import_node_path15.default.resolve(process.argv[1]), params.command, ...params.args],
           {
             cwd: projectRoot8,
             env,
@@ -27504,8 +27661,8 @@ var init_researchAuto = __esm({
       const jsonOutput = Boolean(flags23.json);
       const skipAgent = Boolean(flags23.skipAgent);
       const outDirArg = String(flags23.outDir || "data/ai/export").trim() || "data/ai/export";
-      const outDir = import_node_path14.default.resolve(projectRoot8, outDirArg);
-      const cleanDirArg = import_node_path14.default.relative(import_node_path14.default.join(projectRoot8, "data"), outDir).replace(/\\/g, "/");
+      const outDir = import_node_path15.default.resolve(projectRoot8, outDirArg);
+      const cleanDirArg = import_node_path15.default.relative(import_node_path15.default.join(projectRoot8, "data"), outDir).replace(/\\/g, "/");
       const target = await resolveTarget();
       const runId = `${Date.now()}-${(0, import_ai8.toFileToken)(target.strategy)}`;
       const run = {
@@ -27853,7 +28010,7 @@ var init_types = __esm({
 function assert(condition, message) {
   if (!condition) throw new Error(`Invalid core research spec: ${message}`);
 }
-var import_node_crypto10, import_node_fs3, import_promises22, import_backtest5, import_node_path15, RESEARCH_ID_RE, SHA256_RE, canonicalJson, sha256Text, sha256Json, sha256File, assertFinite, validateCoreResearchSpec, loadCoreResearchSpec, resolveCoreResearchPaths, writeJsonAtomic, buildLedgerRecordHash, readCoreResearchLedger, verifyCoreResearchLedger, appendCoreResearchLedger, validateCoreResearchParentLineage, prepareCoreResearch, verifyCoreResearchArtifacts, scanCoreResearchStages, writeCoreResearchStageIndex;
+var import_node_crypto10, import_node_fs3, import_promises22, import_backtest5, import_node_path16, RESEARCH_ID_RE, SHA256_RE, canonicalJson, sha256Text, sha256Json, sha256File, assertFinite, validateCoreResearchSpec, loadCoreResearchSpec, resolveCoreResearchPaths, writeJsonAtomic, buildLedgerRecordHash, readCoreResearchLedger, verifyCoreResearchLedger, appendCoreResearchLedger, validateCoreResearchParentLineage, prepareCoreResearch, verifyCoreResearchArtifacts, scanCoreResearchStages, writeCoreResearchStageIndex;
 var init_io = __esm({
   "src/lib/coreResearch/io.ts"() {
     "use strict";
@@ -27861,7 +28018,7 @@ var init_io = __esm({
     import_node_fs3 = require("fs");
     import_promises22 = __toESM(require("fs/promises"));
     import_backtest5 = require("@tradejs/core/backtest");
-    import_node_path15 = __toESM(require("path"));
+    import_node_path16 = __toESM(require("path"));
     init_types();
     RESEARCH_ID_RE = /^[a-z0-9][a-z0-9._-]{2,120}$/;
     SHA256_RE = /^[a-f0-9]{64}$/;
@@ -28120,30 +28277,30 @@ var init_io = __esm({
       return spec;
     };
     loadCoreResearchSpec = async (specPath) => {
-      const resolvedPath = import_node_path15.default.resolve(specPath);
+      const resolvedPath = import_node_path16.default.resolve(specPath);
       const parsed = JSON.parse(await import_promises22.default.readFile(resolvedPath, "utf8"));
       const spec = validateCoreResearchSpec(parsed);
       return { resolvedPath, spec, specSha256: sha256Json(spec) };
     };
     resolveCoreResearchPaths = (spec) => {
-      const rootDir = import_node_path15.default.resolve(spec.artifacts.rootDir);
-      const researchDir = import_node_path15.default.join(rootDir, spec.researchId);
+      const rootDir = import_node_path16.default.resolve(spec.artifacts.rootDir);
+      const researchDir = import_node_path16.default.join(rootDir, spec.researchId);
       return {
         rootDir,
         researchDir,
-        ledgerPath: import_node_path15.default.resolve(spec.artifacts.ledgerPath),
-        specPath: import_node_path15.default.join(researchDir, "spec.json"),
-        manifestPath: import_node_path15.default.join(researchDir, "manifest.json"),
-        resultPath: import_node_path15.default.join(researchDir, "result.json"),
-        comparisonPath: import_node_path15.default.join(researchDir, "comparison.json"),
-        matchesPath: import_node_path15.default.join(researchDir, "matches.csv"),
-        tradesPath: import_node_path15.default.join(researchDir, "trades.jsonl"),
-        reportPath: import_node_path15.default.join(researchDir, "report.html"),
-        runLogDir: import_node_path15.default.join(researchDir, "runs")
+        ledgerPath: import_node_path16.default.resolve(spec.artifacts.ledgerPath),
+        specPath: import_node_path16.default.join(researchDir, "spec.json"),
+        manifestPath: import_node_path16.default.join(researchDir, "manifest.json"),
+        resultPath: import_node_path16.default.join(researchDir, "result.json"),
+        comparisonPath: import_node_path16.default.join(researchDir, "comparison.json"),
+        matchesPath: import_node_path16.default.join(researchDir, "matches.csv"),
+        tradesPath: import_node_path16.default.join(researchDir, "trades.jsonl"),
+        reportPath: import_node_path16.default.join(researchDir, "report.html"),
+        runLogDir: import_node_path16.default.join(researchDir, "runs")
       };
     };
     writeJsonAtomic = async (filePath, value) => {
-      await import_promises22.default.mkdir(import_node_path15.default.dirname(filePath), { recursive: true });
+      await import_promises22.default.mkdir(import_node_path16.default.dirname(filePath), { recursive: true });
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
       await import_promises22.default.writeFile(temporaryPath, `${canonicalJson(value)}
 `, "utf8");
@@ -28190,7 +28347,7 @@ var init_io = __esm({
     };
     appendCoreResearchLedger = async (params) => {
       const { ledgerPath } = params;
-      await import_promises22.default.mkdir(import_node_path15.default.dirname(ledgerPath), { recursive: true });
+      await import_promises22.default.mkdir(import_node_path16.default.dirname(ledgerPath), { recursive: true });
       const lockPath = `${ledgerPath}.lock`;
       let lock = null;
       try {
@@ -28229,14 +28386,14 @@ var init_io = __esm({
     validateCoreResearchParentLineage = async (spec) => {
       if (spec.stage === "screen") return;
       const expectedParentStage = spec.stage === "isolated_long" ? "screen" : "isolated_long";
-      const rootDir = import_node_path15.default.resolve(spec.artifacts.rootDir);
+      const rootDir = import_node_path16.default.resolve(spec.artifacts.rootDir);
       const passedParentCandidateConfigShas = /* @__PURE__ */ new Set();
       for (const parentResearchId of spec.parentResearchIds ?? []) {
-        const parentDir = import_node_path15.default.join(rootDir, parentResearchId);
+        const parentDir = import_node_path16.default.join(rootDir, parentResearchId);
         const [parentSpec, parentManifest, parentResult] = await Promise.all([
-          import_promises22.default.readFile(import_node_path15.default.join(parentDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
-          import_promises22.default.readFile(import_node_path15.default.join(parentDir, "manifest.json"), "utf8").then((text) => JSON.parse(text)),
-          import_promises22.default.readFile(import_node_path15.default.join(parentDir, "result.json"), "utf8").then((text) => JSON.parse(text))
+          import_promises22.default.readFile(import_node_path16.default.join(parentDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
+          import_promises22.default.readFile(import_node_path16.default.join(parentDir, "manifest.json"), "utf8").then((text) => JSON.parse(text)),
+          import_promises22.default.readFile(import_node_path16.default.join(parentDir, "result.json"), "utf8").then((text) => JSON.parse(text))
         ]);
         validateCoreResearchSpec(parentSpec);
         if (parentManifest.status !== "completed") {
@@ -28349,7 +28506,7 @@ var init_io = __esm({
         manifest.artifactHashes
       )) {
         const actualHash = await sha256File(
-          import_node_path15.default.join(paths.researchDir, relativePath)
+          import_node_path16.default.join(paths.researchDir, relativePath)
         );
         if (actualHash !== expectedHash) {
           throw new Error(`Artifact hash mismatch: ${relativePath}`);
@@ -28365,7 +28522,7 @@ var init_io = __esm({
       };
     };
     scanCoreResearchStages = async (rootDir) => {
-      const resolvedRoot = import_node_path15.default.resolve(rootDir);
+      const resolvedRoot = import_node_path16.default.resolve(rootDir);
       let entries = [];
       try {
         entries = await import_promises22.default.readdir(resolvedRoot);
@@ -28383,15 +28540,15 @@ var init_io = __esm({
       for (const entry of entries.sort(
         (left, right) => left < right ? -1 : left > right ? 1 : 0
       )) {
-        const researchDir = import_node_path15.default.join(resolvedRoot, entry);
+        const researchDir = import_node_path16.default.join(resolvedRoot, entry);
         const stats = await import_promises22.default.stat(researchDir);
         if (!stats.isDirectory()) continue;
         let spec;
         let manifest;
         try {
           [spec, manifest] = await Promise.all([
-            import_promises22.default.readFile(import_node_path15.default.join(researchDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
-            import_promises22.default.readFile(import_node_path15.default.join(researchDir, "manifest.json"), "utf8").then((text) => JSON.parse(text))
+            import_promises22.default.readFile(import_node_path16.default.join(researchDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
+            import_promises22.default.readFile(import_node_path16.default.join(researchDir, "manifest.json"), "utf8").then((text) => JSON.parse(text))
           ]);
         } catch (error) {
           if (error.code === "ENOENT") continue;
@@ -28401,7 +28558,7 @@ var init_io = __esm({
         if (manifest.specSha256 !== sha256Json(spec)) {
           throw new Error(`Stage index found a spec hash mismatch for ${entry}`);
         }
-        const result = manifest.status === "completed" ? await import_promises22.default.readFile(import_node_path15.default.join(researchDir, "result.json"), "utf8").then((text) => JSON.parse(text)) : null;
+        const result = manifest.status === "completed" ? await import_promises22.default.readFile(import_node_path16.default.join(researchDir, "result.json"), "utf8").then((text) => JSON.parse(text)) : null;
         familyByResearch.set(spec.researchId, spec.hypothesis.family);
         experiments.push({
           researchId: spec.researchId,
@@ -28432,7 +28589,7 @@ var init_io = __esm({
       return { experiments, familyByResearch };
     };
     writeCoreResearchStageIndex = async (rootDir) => {
-      const resolvedRoot = import_node_path15.default.resolve(rootDir);
+      const resolvedRoot = import_node_path16.default.resolve(rootDir);
       const { experiments, familyByResearch } = await scanCoreResearchStages(resolvedRoot);
       const grouped = /* @__PURE__ */ new Map();
       for (const experiment of experiments) {
@@ -28449,21 +28606,21 @@ var init_io = __esm({
         generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         families: [...grouped.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([family, experiments2]) => ({ family, experiments: experiments2 }))
       };
-      await writeJsonAtomic(import_node_path15.default.join(resolvedRoot, "index.json"), index);
+      await writeJsonAtomic(import_node_path16.default.join(resolvedRoot, "index.json"), index);
       return index;
     };
   }
 });
 
 // src/lib/coreResearch/artifacts.ts
-var import_node_fs4, import_node_events, import_promises23, import_node_path16, csv, writeLine, closeOutput, writeCoreResearchMatches, writeCoreResearchTrades;
+var import_node_fs4, import_node_events, import_promises23, import_node_path17, csv, writeLine, closeOutput, writeCoreResearchMatches, writeCoreResearchTrades;
 var init_artifacts = __esm({
   "src/lib/coreResearch/artifacts.ts"() {
     "use strict";
     import_node_fs4 = require("fs");
     import_node_events = require("events");
     import_promises23 = __toESM(require("fs/promises"));
-    import_node_path16 = __toESM(require("path"));
+    import_node_path17 = __toESM(require("path"));
     init_io();
     csv = (value) => {
       const text = String(value ?? "");
@@ -28477,7 +28634,7 @@ var init_artifacts = __esm({
       await (0, import_node_events.once)(output, "close");
     };
     writeCoreResearchMatches = async (params) => {
-      await import_promises23.default.mkdir(import_node_path16.default.dirname(params.filePath), { recursive: true });
+      await import_promises23.default.mkdir(import_node_path17.default.dirname(params.filePath), { recursive: true });
       const output = (0, import_node_fs4.createWriteStream)(params.filePath, { encoding: "utf8" });
       await writeLine(
         output,
@@ -28528,7 +28685,7 @@ var init_artifacts = __esm({
       await closeOutput(output);
     };
     writeCoreResearchTrades = async (params) => {
-      await import_promises23.default.mkdir(import_node_path16.default.dirname(params.filePath), { recursive: true });
+      await import_promises23.default.mkdir(import_node_path17.default.dirname(params.filePath), { recursive: true });
       const output = (0, import_node_fs4.createWriteStream)(params.filePath, { encoding: "utf8" });
       for (const variant of params.variants) {
         for (const trade of variant.trades) {
@@ -29242,13 +29399,13 @@ var init_comparison = __esm({
 });
 
 // src/lib/coreResearch/dataset.ts
-var import_node_crypto12, import_node_fs5, import_node_path17, import_node_readline2, asRecord4, finiteNumber4, normalizeDirection, findStrategySetupIdentity, classifyBreadth, classifyDerivatives, resolveCoreResearchRegime, normalizeCompletedTrade, completedTradeIdentity, positionCycleIdentity, sumBy, weightedPrice, aggregatePositionCycles, compareText, compareTrades, readCoreResearchVariant;
+var import_node_crypto12, import_node_fs5, import_node_path18, import_node_readline2, asRecord4, finiteNumber4, normalizeDirection, findStrategySetupIdentity, classifyBreadth, classifyDerivatives, resolveCoreResearchRegime, normalizeCompletedTrade, completedTradeIdentity, positionCycleIdentity, sumBy, weightedPrice, aggregatePositionCycles, compareText, compareTrades, readCoreResearchVariant;
 var init_dataset2 = __esm({
   "src/lib/coreResearch/dataset.ts"() {
     "use strict";
     import_node_crypto12 = require("crypto");
     import_node_fs5 = require("fs");
-    import_node_path17 = __toESM(require("path"));
+    import_node_path18 = __toESM(require("path"));
     import_node_readline2 = __toESM(require("readline"));
     asRecord4 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
     finiteNumber4 = (value, field) => {
@@ -29344,7 +29501,7 @@ var init_dataset2 = __esm({
       };
     };
     normalizeCompletedTrade = (params) => {
-      const { filePath, fileSha256, lineNumber, row } = params;
+      const { filePath, fileSha256: fileSha2562, lineNumber, row } = params;
       const result = row.tradeResult;
       if (!result) return null;
       const signalTimestamp = finiteNumber4(row.timestamp, "row.timestamp");
@@ -29359,7 +29516,7 @@ var init_dataset2 = __esm({
       return {
         sourceFile: filePath,
         sourceLine: lineNumber,
-        sourceSha256: fileSha256,
+        sourceSha256: fileSha2562,
         runId: row.backtestRunId ?? null,
         configId: row.configId?.trim() || "<missing-config-id>",
         signalId,
@@ -29459,7 +29616,7 @@ var init_dataset2 = __esm({
       const seen = /* @__PURE__ */ new Map();
       let duplicateRowsDropped = 0;
       for (const inputPath of variant.files) {
-        const filePath = import_node_path17.default.resolve(inputPath);
+        const filePath = import_node_path18.default.resolve(inputPath);
         const input = (0, import_node_fs5.createReadStream)(filePath);
         const hash = (0, import_node_crypto12.createHash)("sha256");
         input.on("data", (chunk) => hash.update(chunk));
@@ -29512,11 +29669,11 @@ var init_dataset2 = __esm({
           trades.push(trade);
           fileTrades.push(trade);
         }
-        const fileSha256 = hash.digest("hex");
-        for (const trade of fileTrades) trade.sourceSha256 = fileSha256;
+        const fileSha2562 = hash.digest("hex");
+        for (const trade of fileTrades) trade.sourceSha256 = fileSha2562;
         sources.push({
           path: filePath,
-          sha256: fileSha256,
+          sha256: fileSha2562,
           rows,
           selectedTrades,
           rowsForDifferentRun,
@@ -29951,18 +30108,18 @@ var init_selection = __esm({
 });
 
 // src/lib/coreResearch/trace.ts
-var import_promises24, import_node_path18, summarizeCoreResearchTrace;
+var import_promises24, import_node_path19, summarizeCoreResearchTrace;
 var init_trace = __esm({
   "src/lib/coreResearch/trace.ts"() {
     "use strict";
     import_promises24 = __toESM(require("fs/promises"));
-    import_node_path18 = __toESM(require("path"));
+    import_node_path19 = __toESM(require("path"));
     summarizeCoreResearchTrace = async (filePaths = []) => {
       const events = /* @__PURE__ */ Object.create(null);
       const skipCounts = /* @__PURE__ */ Object.create(null);
       const exitCodes = /* @__PURE__ */ Object.create(null);
       for (const inputPath of filePaths) {
-        const filePath = import_node_path18.default.resolve(inputPath);
+        const filePath = import_node_path19.default.resolve(inputPath);
         const text = await import_promises24.default.readFile(filePath, "utf8");
         for (const [index, line] of text.split("\n").entries()) {
           if (!line.trim()) continue;
@@ -30003,12 +30160,12 @@ var init_trace = __esm({
 });
 
 // src/lib/coreResearch/orchestrator.ts
-var import_promises25, import_node_path19, import_node_child_process6, import_node_crypto13, import_coreResearch, summarizeSupplementalFiles, analyzeCoreResearchPrepared, analyzeCoreResearch, createCoreResearchSpecTemplate, runCommand2, commandValue, commandHas, validateCoreResearchRunCommand, runCoreResearch;
+var import_promises25, import_node_path20, import_node_child_process6, import_node_crypto13, import_coreResearch, summarizeSupplementalFiles, analyzeCoreResearchPrepared, analyzeCoreResearch, createCoreResearchSpecTemplate, runCommand2, commandValue, commandHas, validateCoreResearchRunCommand, runCoreResearch;
 var init_orchestrator = __esm({
   "src/lib/coreResearch/orchestrator.ts"() {
     "use strict";
     import_promises25 = __toESM(require("fs/promises"));
-    import_node_path19 = __toESM(require("path"));
+    import_node_path20 = __toESM(require("path"));
     import_node_child_process6 = require("child_process");
     import_node_crypto13 = require("crypto");
     import_coreResearch = require("@tradejs/infra/coreResearch");
@@ -30215,7 +30372,7 @@ var init_orchestrator = __esm({
       const primarySourceHashes = Object.fromEntries(
         analyses.flatMap(
           (analysis) => analysis.files.map((file) => [
-            import_node_path19.default.relative(paths.researchDir, file.path),
+            import_node_path20.default.relative(paths.researchDir, file.path),
             file.sha256
           ])
         )
@@ -30234,8 +30391,8 @@ var init_orchestrator = __esm({
       const supplementalSourceHashes = Object.fromEntries(
         await Promise.all(
           supplementalSourcePaths.map(async (filePath) => [
-            import_node_path19.default.relative(paths.researchDir, import_node_path19.default.resolve(filePath)),
-            await sha256File(import_node_path19.default.resolve(filePath))
+            import_node_path20.default.relative(paths.researchDir, import_node_path20.default.resolve(filePath)),
+            await sha256File(import_node_path20.default.resolve(filePath))
           ])
         )
       );
@@ -30312,7 +30469,7 @@ var init_orchestrator = __esm({
         "trades.jsonl": await sha256File(paths.tradesPath),
         "report.html": await sha256File(paths.reportPath)
       };
-      const resolvedRunsPath = import_node_path19.default.join(paths.researchDir, "resolved-runs.json");
+      const resolvedRunsPath = import_node_path20.default.join(paths.researchDir, "resolved-runs.json");
       try {
         artifactHashes["resolved-runs.json"] = await sha256File(resolvedRunsPath);
       } catch (error) {
@@ -30322,7 +30479,7 @@ var init_orchestrator = __esm({
         for (const name of await import_promises25.default.readdir(paths.runLogDir)) {
           if (!name.endsWith(".log")) continue;
           artifactHashes[`runs/${name}`] = await sha256File(
-            import_node_path19.default.join(paths.runLogDir, name)
+            import_node_path20.default.join(paths.runLogDir, name)
           );
         }
       } catch (error) {
@@ -30379,9 +30536,9 @@ var init_orchestrator = __esm({
       }
     };
     createCoreResearchSpecTemplate = (params) => {
-      const rootDir = import_node_path19.default.relative(
-        import_node_path19.default.resolve(params.projectRoot),
-        import_node_path19.default.join(import_node_path19.default.resolve(params.projectRoot), "data", "research", "core")
+      const rootDir = import_node_path20.default.relative(
+        import_node_path20.default.resolve(params.projectRoot),
+        import_node_path20.default.join(import_node_path20.default.resolve(params.projectRoot), "data", "research", "core")
       ).replace(/\\/g, "/");
       const lineage = (() => {
         try {
@@ -30519,7 +30676,7 @@ var init_orchestrator = __esm({
     };
     runCommand2 = async (params) => {
       if (!params.command.length) throw new Error("Cannot run an empty command");
-      await import_promises25.default.mkdir(import_node_path19.default.dirname(params.logPath), { recursive: true });
+      await import_promises25.default.mkdir(import_node_path20.default.dirname(params.logPath), { recursive: true });
       const chunks = [];
       const child = (0, import_node_child_process6.spawn)(params.command[0], params.command.slice(1), {
         cwd: params.cwd,
@@ -30593,7 +30750,7 @@ var init_orchestrator = __esm({
     };
     runCoreResearch = async (params) => {
       const { spec } = params;
-      const cwd = import_node_path19.default.resolve(params.cwd ?? process.cwd());
+      const cwd = import_node_path20.default.resolve(params.cwd ?? process.cwd());
       const prepared = await prepareCoreResearch(spec);
       const resolvedVariants = [];
       for (const variant of spec.variants) {
@@ -30611,7 +30768,7 @@ var init_orchestrator = __esm({
           artifactHashes: { variant: sha256Json(variant) }
         });
         let runId = "";
-        const backtestLogPath = import_node_path19.default.join(
+        const backtestLogPath = import_node_path20.default.join(
           prepared.paths.runLogDir,
           `${variant.id}-backtest.log`
         );
@@ -30627,7 +30784,7 @@ var init_orchestrator = __esm({
             env: {
               PROJECT_CWD: cwd,
               ...params.sourceRepositoryRoot ? {
-                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path19.default.resolve(
+                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path20.default.resolve(
                   params.sourceRepositoryRoot
                 )
               } : {}
@@ -30642,12 +30799,12 @@ var init_orchestrator = __esm({
           if (!runId) {
             throw new Error(`Backtest for ${variant.id} did not report a run id`);
           }
-          const exportLogPath = import_node_path19.default.join(
+          const exportLogPath = import_node_path20.default.join(
             prepared.paths.runLogDir,
             `${variant.id}-export.log`
           );
           const exportParts = [];
-          const cliPath = import_node_path19.default.resolve(process.argv[1]);
+          const cliPath = import_node_path20.default.resolve(process.argv[1]);
           await runCommand2({
             command: [
               process.execPath,
@@ -30667,14 +30824,14 @@ var init_orchestrator = __esm({
             env: {
               PROJECT_CWD: cwd,
               ...params.sourceRepositoryRoot ? {
-                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path19.default.resolve(
+                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path20.default.resolve(
                   params.sourceRepositoryRoot
                 )
               } : {}
             },
             onLine: (line) => {
               const match = line.match(/^part\d+:\s+(.+)$/);
-              if (match) exportParts.push(import_node_path19.default.resolve(cwd, match[1].trim()));
+              if (match) exportParts.push(import_node_path20.default.resolve(cwd, match[1].trim()));
             }
           });
           if (!exportParts.length) {
@@ -30685,7 +30842,7 @@ var init_orchestrator = __esm({
           const traceFiles = await (0, import_coreResearch.listCoreResearchTraceFiles)({
             strategyName: spec.strategy,
             runId,
-            outDir: import_node_path19.default.resolve(cwd, "data/research/core/trace")
+            outDir: import_node_path20.default.resolve(cwd, "data/research/core/trace")
           });
           resolvedVariants.push({
             ...variant,
@@ -30705,7 +30862,7 @@ var init_orchestrator = __esm({
               ...Object.fromEntries(
                 await Promise.all(
                   exportParts.map(async (filePath) => [
-                    import_node_path19.default.basename(filePath),
+                    import_node_path20.default.basename(filePath),
                     await sha256File(filePath)
                   ])
                 )
@@ -30724,7 +30881,7 @@ var init_orchestrator = __esm({
         }
       }
       await writeJsonAtomic(
-        import_node_path19.default.join(prepared.paths.researchDir, "resolved-runs.json"),
+        import_node_path20.default.join(prepared.paths.researchDir, "resolved-runs.json"),
         {
           schema: "tradejs-core-research-resolved-runs/v1",
           researchId: spec.researchId,
@@ -30744,12 +30901,12 @@ var coreResearch_exports = {};
 __export(coreResearch_exports, {
   main: () => main34
 });
-var import_promises26, import_node_path20, import_chalk41, valueAfter, required, parseTimestamp, readSymbols, printUsage, main34;
+var import_promises26, import_node_path21, import_chalk41, valueAfter, required, parseTimestamp, readSymbols, printUsage, main34;
 var init_coreResearch = __esm({
   "src/scripts/coreResearch.ts"() {
     "use strict";
     import_promises26 = __toESM(require("fs/promises"));
-    import_node_path20 = __toESM(require("path"));
+    import_node_path21 = __toESM(require("path"));
     import_chalk41 = __toESM(require("chalk"));
     init_io();
     init_orchestrator();
@@ -30773,7 +30930,7 @@ var init_coreResearch = __esm({
       const symbolsFile = valueAfter(argv2, "--symbolsFile");
       if (symbolsFile) {
         const parsed = JSON.parse(
-          await import_promises26.default.readFile(import_node_path20.default.resolve(projectRoot18, symbolsFile), "utf8")
+          await import_promises26.default.readFile(import_node_path21.default.resolve(projectRoot18, symbolsFile), "utf8")
         );
         if (!Array.isArray(parsed) || parsed.some((symbol) => typeof symbol !== "string")) {
           throw new Error("--symbolsFile must contain a JSON string array");
@@ -30804,14 +30961,14 @@ The run command executes only variants with an explicit command[] in the preregi
         return;
       }
       if (command === "index") {
-        const rootDir = import_node_path20.default.resolve(
+        const rootDir = import_node_path21.default.resolve(
           roots.projectRoot,
           required(valueAfter(argv2, "--root"), "--root")
         );
         const index = await writeCoreResearchStageIndex(rootDir);
         console.log(
           import_chalk41.default.green(
-            `Core research index: ${import_node_path20.default.join(rootDir, "index.json")} (${index.families.length} families)`
+            `Core research index: ${import_node_path21.default.join(rootDir, "index.json")} (${index.families.length} families)`
           )
         );
         return;
@@ -30820,7 +30977,7 @@ The run command executes only variants with an explicit command[] in the preregi
         projectRoot: roots.projectRoot
       });
       if (command === "init") {
-        const outputPath = import_node_path20.default.resolve(
+        const outputPath = import_node_path21.default.resolve(
           roots.projectRoot,
           required(valueAfter(argv2, "--out"), "--out")
         );
@@ -30844,7 +31001,7 @@ The run command executes only variants with an explicit command[] in the preregi
         );
         return;
       }
-      const specPath = import_node_path20.default.resolve(
+      const specPath = import_node_path21.default.resolve(
         roots.projectRoot,
         required(valueAfter(argv2, "--spec"), "--spec")
       );
@@ -31498,12 +31655,12 @@ __export(replayRuntimeEvidence_exports, {
   replayRuntimeEvidence: () => replayRuntimeEvidence,
   summarizeReplayComparison: () => summarizeReplayComparison
 });
-var import_promises27, import_node_path21, import_args27, import_chalk43, import_redis19, toEpochMs2, resolveWindow, parseStrategyFilter, asRecord5, asArray2, sum, groupCount, compactMatched, resolveItemStrategy, summarizeReplayComparison, loadReplayResult, getReplayStrategies, loadRuntimePayload, replayRuntimeEvidence, main36;
+var import_promises27, import_node_path22, import_args27, import_chalk43, import_redis19, toEpochMs2, resolveWindow, parseStrategyFilter, asRecord5, asArray2, sum, groupCount, compactMatched, resolveItemStrategy, summarizeReplayComparison, loadReplayResult, getReplayStrategies, loadRuntimePayload, replayRuntimeEvidence, main36;
 var init_replayRuntimeEvidence = __esm({
   "src/scripts/replayRuntimeEvidence.ts"() {
     "use strict";
     import_promises27 = __toESM(require("fs/promises"));
-    import_node_path21 = __toESM(require("path"));
+    import_node_path22 = __toESM(require("path"));
     import_args27 = __toESM(require("args"));
     import_chalk43 = __toESM(require("chalk"));
     import_redis19 = require("@tradejs/infra/redis");
@@ -31762,7 +31919,7 @@ var init_replayRuntimeEvidence = __esm({
       runtimeEvidenceFile,
       projectRoot: projectRoot18
     }) => {
-      const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path21.default.resolve(projectRoot18, runtimeEvidenceFile.trim()) : null;
+      const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path22.default.resolve(projectRoot18, runtimeEvidenceFile.trim()) : null;
       if (runtimeEvidencePath) {
         const artifact = JSON.parse(
           await import_promises27.default.readFile(runtimeEvidencePath, "utf8")
@@ -31851,8 +32008,8 @@ var init_replayRuntimeEvidence = __esm({
         },
         runtime: runtime.payload
       };
-      const outPath = import_node_path21.default.resolve(projectRoot18, String(flags35.out));
-      await import_promises27.default.mkdir(import_node_path21.default.dirname(outPath), { recursive: true });
+      const outPath = import_node_path22.default.resolve(projectRoot18, String(flags35.out));
+      await import_promises27.default.mkdir(import_node_path22.default.dirname(outPath), { recursive: true });
       await import_promises27.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
       console.log(import_chalk43.default.green(`Wrote ${outPath}`));
@@ -31875,24 +32032,6 @@ var init_replayRuntimeEvidence = __esm({
   }
 });
 
-// src/lib/runtimeEvidenceArtifacts.ts
-var runtimeEvidenceArtifacts_exports = {};
-var init_runtimeEvidenceArtifacts = __esm({
-  "src/lib/runtimeEvidenceArtifacts.ts"() {
-    "use strict";
-    __reExport(runtimeEvidenceArtifacts_exports, require("@tradejs/node/diagnostics"));
-  }
-});
-
-// src/lib/runtimeEvidenceProducer.ts
-var runtimeEvidenceProducer_exports = {};
-var init_runtimeEvidenceProducer = __esm({
-  "src/lib/runtimeEvidenceProducer.ts"() {
-    "use strict";
-    __reExport(runtimeEvidenceProducer_exports, require("@tradejs/node/diagnostics"));
-  }
-});
-
 // src/lib/runtimeFeedbackArtifacts.ts
 var runtimeFeedbackArtifacts_exports = {};
 var init_runtimeFeedbackArtifacts = __esm({
@@ -31903,13 +32042,13 @@ var init_runtimeFeedbackArtifacts = __esm({
 });
 
 // src/lib/runtimeFeedbackReplay.ts
-var import_node_child_process7, import_promises28, import_node_path22, REQUIRED_ENV, FORBIDDEN_SECRET_ENV, unsafeRedisHosts, safeSegment, assertRuntimeFeedbackReplaySafety, buildRuntimeFeedbackReplayCommands, runLoggedCommand, runRuntimeFeedbackReplay;
+var import_node_child_process7, import_promises28, import_node_path23, REQUIRED_ENV, FORBIDDEN_SECRET_ENV, unsafeRedisHosts, safeSegment, assertRuntimeFeedbackReplaySafety, buildRuntimeFeedbackReplayCommands, runLoggedCommand, runRuntimeFeedbackReplay;
 var init_runtimeFeedbackReplay = __esm({
   "src/lib/runtimeFeedbackReplay.ts"() {
     "use strict";
     import_node_child_process7 = require("child_process");
     import_promises28 = __toESM(require("fs/promises"));
-    import_node_path22 = __toESM(require("path"));
+    import_node_path23 = __toESM(require("path"));
     init_runtimeEvidenceDeployment();
     init_runtimeEvidenceArtifacts();
     init_runtimeEvidenceProducer();
@@ -32096,9 +32235,9 @@ $ ${[executable, ...command].join(" ")}
         throw new Error("Cannot resolve the TradeJS CLI executable path");
       }
       const runtimeEvidenceBundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(
-        import_node_path22.default.dirname(runtimeEvidencePath)
+        import_node_path23.default.dirname(runtimeEvidencePath)
       );
-      if (import_node_path22.default.resolve(runtimeEvidenceBundle.payloadPath) !== runtimeEvidencePath) {
+      if (import_node_path23.default.resolve(runtimeEvidenceBundle.payloadPath) !== runtimeEvidencePath) {
         throw new Error(
           `Runtime evidence must be the verified bundle payload: ${runtimeEvidenceBundle.payloadPath}`
         );
@@ -32132,9 +32271,9 @@ $ ${[executable, ...command].join(" ")}
           `Runtime feedback output directory must be empty: ${outDir}`
         );
       }
-      const replayEvidencePath = import_node_path22.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_REPLAY_FILE);
+      const replayEvidencePath = import_node_path23.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_REPLAY_FILE);
       const logHandle = await import_promises28.default.open(
-        import_node_path22.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_LOG_FILE),
+        import_node_path23.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_LOG_FILE),
         "wx"
       );
       const commands = buildRuntimeFeedbackReplayCommands({
@@ -32176,11 +32315,11 @@ __export(runtimeFeedbackReplay_exports, {
   main: () => main37,
   runtimeFeedbackReplay: () => runtimeFeedbackReplay
 });
-var import_node_path23, import_args28, import_chalk44, flags25, projectRoot9, runtimeFeedbackReplay, main37;
+var import_node_path24, import_args28, import_chalk44, flags25, projectRoot9, runtimeFeedbackReplay, main37;
 var init_runtimeFeedbackReplay2 = __esm({
   "src/scripts/runtimeFeedbackReplay.ts"() {
     "use strict";
-    import_node_path23 = __toESM(require("path"));
+    import_node_path24 = __toESM(require("path"));
     import_args28 = __toESM(require("args"));
     import_chalk44 = __toESM(require("chalk"));
     init_runtimeFeedbackReplay();
@@ -32198,8 +32337,8 @@ var init_runtimeFeedbackReplay2 = __esm({
         );
       }
       const verified = await runRuntimeFeedbackReplay({
-        runtimeEvidencePath: import_node_path23.default.resolve(projectRoot9, runtimeEvidence2),
-        outDir: import_node_path23.default.resolve(projectRoot9, outDir),
+        runtimeEvidencePath: import_node_path24.default.resolve(projectRoot9, runtimeEvidence2),
+        outDir: import_node_path24.default.resolve(projectRoot9, outDir),
         runId: String(flags25.runId ?? "").trim() || void 0,
         projectRoot: projectRoot9
       });
@@ -32357,11 +32496,11 @@ __export(runtimeFeedbackNotify_exports, {
   main: () => main38,
   runtimeFeedbackNotify: () => runtimeFeedbackNotify
 });
-var import_node_path24, import_args29, import_chalk45, flags26, projectRoot10, runtimeFeedbackNotify, main38;
+var import_node_path25, import_args29, import_chalk45, flags26, projectRoot10, runtimeFeedbackNotify, main38;
 var init_runtimeFeedbackNotify = __esm({
   "src/scripts/runtimeFeedbackNotify.ts"() {
     "use strict";
-    import_node_path24 = __toESM(require("path"));
+    import_node_path25 = __toESM(require("path"));
     import_args29 = __toESM(require("args"));
     import_chalk45 = __toESM(require("chalk"));
     init_runtimeFeedbackNotification();
@@ -32375,7 +32514,7 @@ var init_runtimeFeedbackNotify = __esm({
       if (!bundle) {
         throw new Error("Provide --bundle for runtime feedback notification.");
       }
-      const bundleDir = import_node_path24.default.resolve(projectRoot10, bundle);
+      const bundleDir = import_node_path25.default.resolve(projectRoot10, bundle);
       if (flags26.dryRun) {
         const verified = await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(bundleDir);
         console.log(buildRuntimeFeedbackTelegramMessage(verified.replayEvidence));
@@ -32391,13 +32530,13 @@ var init_runtimeFeedbackNotify = __esm({
 });
 
 // src/lib/runtimeEvidenceSync.ts
-var import_node_child_process8, import_promises29, import_node_path25, import_node_util, execFileAsync, isExistingDestinationError, safeSegment2, withTrailingSlash, dateParts, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
+var import_node_child_process8, import_promises29, import_node_path26, import_node_util, execFileAsync, isExistingDestinationError, safeSegment2, withTrailingSlash, dateParts, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
 var init_runtimeEvidenceSync = __esm({
   "src/lib/runtimeEvidenceSync.ts"() {
     "use strict";
     import_node_child_process8 = require("child_process");
     import_promises29 = __toESM(require("fs/promises"));
-    import_node_path25 = __toESM(require("path"));
+    import_node_path26 = __toESM(require("path"));
     import_node_util = require("util");
     init_runtimeEvidenceArtifacts();
     init_runtimeEvidenceDeployment();
@@ -32431,15 +32570,15 @@ var init_runtimeEvidenceSync = __esm({
       withTrailingSlash(source),
       withTrailingSlash(destination)
     ];
-    receiptPath = (receiptsRoot, artifactId) => import_node_path25.default.join(receiptsRoot, `${safeSegment2(artifactId, "artifact")}.json`);
+    receiptPath = (receiptsRoot, artifactId) => import_node_path26.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_path25.default.join(evidenceRoot, "artifacts", safeDeploymentId);
-      const receiptsRoot = import_node_path25.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const artifactsRoot = import_node_path26.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const receiptsRoot = import_node_path26.default.join(evidenceRoot, "receipts", safeDeploymentId);
       const bundles = await (0, runtimeEvidenceArtifacts_exports.discoverRuntimeEvidenceBundles)(artifactsRoot);
       const pending = [];
       for (const bundleDir of bundles) {
@@ -32470,7 +32609,7 @@ var init_runtimeEvidenceSync = __esm({
           `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
         );
       }
-      const receiptsRoot = import_node_path25.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const receiptsRoot = import_node_path26.default.join(evidenceRoot, "receipts", safeDeploymentId);
       const finalPath = receiptPath(receiptsRoot, verified.manifest.artifactId);
       const temporaryPath = `${finalPath}.tmp-${process.pid}`;
       const receipt = {
@@ -32506,8 +32645,8 @@ var init_runtimeEvidenceSync = __esm({
       }
     }) => {
       const safeDeploymentId = safeSegment2(deploymentId, "production");
-      const inboxRoot = import_node_path25.default.join(evidenceRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path25.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const inboxRoot = import_node_path26.default.join(evidenceRoot, "inbox", safeDeploymentId);
+      const artifactsRoot = import_node_path26.default.join(evidenceRoot, "artifacts", safeDeploymentId);
       await Promise.all([
         import_promises29.default.mkdir(inboxRoot, { recursive: true }),
         import_promises29.default.mkdir(artifactsRoot, { recursive: true })
@@ -32527,12 +32666,12 @@ var init_runtimeEvidenceSync = __esm({
           );
         }
         (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(verified.artifact);
-        const destinationDir = import_node_path25.default.join(
+        const destinationDir = import_node_path26.default.join(
           artifactsRoot,
           ...dateParts(verified.manifest.window.endTime),
           safeSegment2(verified.manifest.artifactId, "artifact")
         );
-        await import_promises29.default.mkdir(import_node_path25.default.dirname(destinationDir), { recursive: true });
+        await import_promises29.default.mkdir(import_node_path26.default.dirname(destinationDir), { recursive: true });
         try {
           await import_promises29.default.rename(bundleDir, destinationDir);
         } catch (error) {
@@ -32563,13 +32702,13 @@ var init_runtimeEvidenceSync = __esm({
 });
 
 // src/lib/runtimeFeedbackSync.ts
-var import_node_child_process9, import_promises30, import_node_path26, import_node_util2, execFileAsync2, isExistingDestinationError2, safeSegment3, dateParts2, syncRuntimeFeedbackReplayBundles;
+var import_node_child_process9, import_promises30, import_node_path27, import_node_util2, execFileAsync2, isExistingDestinationError2, safeSegment3, dateParts2, syncRuntimeFeedbackReplayBundles;
 var init_runtimeFeedbackSync = __esm({
   "src/lib/runtimeFeedbackSync.ts"() {
     "use strict";
     import_node_child_process9 = require("child_process");
     import_promises30 = __toESM(require("fs/promises"));
-    import_node_path26 = __toESM(require("path"));
+    import_node_path27 = __toESM(require("path"));
     import_node_util2 = require("util");
     init_runtimeFeedbackArtifacts();
     init_runtimeEvidenceSync();
@@ -32602,8 +32741,8 @@ var init_runtimeFeedbackSync = __esm({
       }
     }) => {
       const safeDeploymentId = safeSegment3(deploymentId, "production");
-      const inboxRoot = import_node_path26.default.join(feedbackRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path26.default.join(feedbackRoot, "artifacts", safeDeploymentId);
+      const inboxRoot = import_node_path27.default.join(feedbackRoot, "inbox", safeDeploymentId);
+      const artifactsRoot = import_node_path27.default.join(feedbackRoot, "artifacts", safeDeploymentId);
       await Promise.all([
         import_promises30.default.mkdir(inboxRoot, { recursive: true }),
         import_promises30.default.mkdir(artifactsRoot, { recursive: true })
@@ -32622,13 +32761,13 @@ var init_runtimeFeedbackSync = __esm({
             `Runtime feedback deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
           );
         }
-        const destinationDir = import_node_path26.default.join(
+        const destinationDir = import_node_path27.default.join(
           artifactsRoot,
           ...dateParts2(verified.manifest.window.endTime),
           safeSegment3(verified.manifest.runtimeEvidence.artifactId, "artifact"),
           safeSegment3(verified.manifest.runId, "run")
         );
-        await import_promises30.default.mkdir(import_node_path26.default.dirname(destinationDir), { recursive: true });
+        await import_promises30.default.mkdir(import_node_path27.default.dirname(destinationDir), { recursive: true });
         try {
           await import_promises30.default.rename(bundleDir, destinationDir);
         } catch (error) {
@@ -32659,11 +32798,11 @@ __export(runtimeFeedbackSync_exports, {
   main: () => main39,
   runtimeFeedbackSync: () => runtimeFeedbackSync
 });
-var import_node_path27, import_args30, import_chalk46, flags27, projectRoot11, runtimeFeedbackSync, main39;
+var import_node_path28, import_args30, import_chalk46, flags27, projectRoot11, runtimeFeedbackSync, main39;
 var init_runtimeFeedbackSync2 = __esm({
   "src/scripts/runtimeFeedbackSync.ts"() {
     "use strict";
-    import_node_path27 = __toESM(require("path"));
+    import_node_path28 = __toESM(require("path"));
     import_args30 = __toESM(require("args"));
     import_chalk46 = __toESM(require("chalk"));
     init_runtimeFeedbackSync();
@@ -32691,7 +32830,7 @@ var init_runtimeFeedbackSync2 = __esm({
           "Provide --source or RUNTIME_FEEDBACK_RSYNC_SOURCE for runtime feedback sync."
         );
       }
-      const feedbackRoot = import_node_path27.default.resolve(projectRoot11, String(flags27.dir));
+      const feedbackRoot = import_node_path28.default.resolve(projectRoot11, String(flags27.dir));
       const result = await syncRuntimeFeedbackReplayBundles({
         source,
         feedbackRoot,
@@ -32723,13 +32862,13 @@ var init_runtimeFeedbackSync2 = __esm({
 });
 
 // src/lib/runtimeEvidenceCompositionSnapshots.ts
-var import_node_crypto14, import_promises31, import_node_path28, SNAPSHOT_FILE, MANIFEST_FILE, COMPLETE_FILE, createRuntimeEvidenceCompositionSnapshotRecorder, isRecord2, sha256, safeSegment4, isExistingDestinationError3, parseManifest, verifyRuntimeEvidenceCompositionSnapshot, sameSnapshot, publishRuntimeEvidenceCompositionSnapshot, captureRuntimeEvidenceCompositionSnapshot, discoverRuntimeEvidenceCompositionSnapshots;
+var import_node_crypto14, import_promises31, import_node_path29, SNAPSHOT_FILE, MANIFEST_FILE, COMPLETE_FILE, createRuntimeEvidenceCompositionSnapshotRecorder, isRecord2, sha256, safeSegment4, isExistingDestinationError3, parseManifest, verifyRuntimeEvidenceCompositionSnapshot, sameSnapshot, publishRuntimeEvidenceCompositionSnapshot, captureRuntimeEvidenceCompositionSnapshot, discoverRuntimeEvidenceCompositionSnapshots;
 var init_runtimeEvidenceCompositionSnapshots = __esm({
   "src/lib/runtimeEvidenceCompositionSnapshots.ts"() {
     "use strict";
     import_node_crypto14 = require("crypto");
     import_promises31 = __toESM(require("fs/promises"));
-    import_node_path28 = __toESM(require("path"));
+    import_node_path29 = __toESM(require("path"));
     init_runtimeEvidenceDeployment();
     init_runtimeEvidenceProducer();
     SNAPSHOT_FILE = "snapshot.json";
@@ -32772,9 +32911,9 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
     };
     verifyRuntimeEvidenceCompositionSnapshot = async (bundleDir) => {
       const [manifestText, payload, completeText] = await Promise.all([
-        import_promises31.default.readFile(import_node_path28.default.join(bundleDir, MANIFEST_FILE), "utf8"),
-        import_promises31.default.readFile(import_node_path28.default.join(bundleDir, SNAPSHOT_FILE)),
-        import_promises31.default.readFile(import_node_path28.default.join(bundleDir, COMPLETE_FILE), "utf8")
+        import_promises31.default.readFile(import_node_path29.default.join(bundleDir, MANIFEST_FILE), "utf8"),
+        import_promises31.default.readFile(import_node_path29.default.join(bundleDir, SNAPSHOT_FILE)),
+        import_promises31.default.readFile(import_node_path29.default.join(bundleDir, COMPLETE_FILE), "utf8")
       ]);
       const manifest = parseManifest(JSON.parse(manifestText));
       if (completeText.trim() !== manifest.deploymentCompositionId) {
@@ -32837,9 +32976,9 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
           bytes: Buffer.byteLength(payload)
         }
       };
-      const snapshotsRoot = import_node_path28.default.join(evidenceRoot, "snapshots", deploymentId);
-      const bundleDir = import_node_path28.default.join(snapshotsRoot, compositionId);
-      const temporaryDir = import_node_path28.default.join(
+      const snapshotsRoot = import_node_path29.default.join(evidenceRoot, "snapshots", deploymentId);
+      const bundleDir = import_node_path29.default.join(snapshotsRoot, compositionId);
+      const temporaryDir = import_node_path29.default.join(
         evidenceRoot,
         "incoming",
         `snapshot-${compositionId}.tmp-${(0, import_node_crypto14.randomUUID)()}`
@@ -32847,16 +32986,16 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
       await import_promises31.default.mkdir(temporaryDir, { recursive: true });
       try {
         await Promise.all([
-          import_promises31.default.writeFile(import_node_path28.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
+          import_promises31.default.writeFile(import_node_path29.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
           import_promises31.default.writeFile(
-            import_node_path28.default.join(temporaryDir, MANIFEST_FILE),
+            import_node_path29.default.join(temporaryDir, MANIFEST_FILE),
             `${JSON.stringify(manifest, null, 2)}
 `,
             "utf8"
           )
         ]);
         await import_promises31.default.writeFile(
-          import_node_path28.default.join(temporaryDir, COMPLETE_FILE),
+          import_node_path29.default.join(temporaryDir, COMPLETE_FILE),
           `${compositionId}
 `,
           "utf8"
@@ -32903,14 +33042,14 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
         );
       }
       await publishRuntimeEvidenceCompositionSnapshot({
-        evidenceRoot: import_node_path28.default.join(projectRoot18, "data", "runtime-evidence"),
+        evidenceRoot: import_node_path29.default.join(projectRoot18, "data", "runtime-evidence"),
         userName: userName3,
         deployment,
         producer
       });
     };
     discoverRuntimeEvidenceCompositionSnapshots = async (evidenceRoot) => {
-      const rootDir = import_node_path28.default.join(evidenceRoot, "snapshots");
+      const rootDir = import_node_path29.default.join(evidenceRoot, "snapshots");
       const bundleDirs = [];
       let deployments;
       try {
@@ -32920,14 +33059,14 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
         throw error;
       }
       for (const deployment of deployments.filter((entry) => entry.isDirectory())) {
-        const deploymentDir = import_node_path28.default.join(rootDir, deployment.name);
+        const deploymentDir = import_node_path29.default.join(rootDir, deployment.name);
         const compositions = await import_promises31.default.readdir(deploymentDir, {
           withFileTypes: true
         });
         bundleDirs.push(
           ...compositions.filter(
             (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
-          ).map((entry) => import_node_path28.default.join(deploymentDir, entry.name))
+          ).map((entry) => import_node_path29.default.join(deploymentDir, entry.name))
         );
       }
       return Promise.all(
@@ -33106,12 +33245,12 @@ __export(runtimeEvidence_exports, {
   main: () => main40,
   runtimeEvidence: () => runtimeEvidence
 });
-var import_promises32, import_node_path29, import_args31, import_chalk47, flags28, projectRoot12, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main40;
+var import_promises32, import_node_path30, import_args31, import_chalk47, flags28, projectRoot12, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main40;
 var init_runtimeEvidence = __esm({
   "src/scripts/runtimeEvidence.ts"() {
     "use strict";
     import_promises32 = __toESM(require("fs/promises"));
-    import_node_path29 = __toESM(require("path"));
+    import_node_path30 = __toESM(require("path"));
     import_args31 = __toESM(require("args"));
     import_chalk47 = __toESM(require("chalk"));
     init_runtimeDebugEvidence();
@@ -33218,7 +33357,7 @@ var init_runtimeEvidence = __esm({
         deploymentId
       });
       const snapshots = publishDir && producer ? await loadRuntimeEvidenceCompositionSnapshots({
-        publishRoot: import_node_path29.default.resolve(projectRoot12, publishDir),
+        publishRoot: import_node_path30.default.resolve(projectRoot12, publishDir),
         currentDeployment: deploymentSnapshot,
         currentProducer: producer
       }) : /* @__PURE__ */ new Map([
@@ -33292,14 +33431,14 @@ var init_runtimeEvidence = __esm({
         throw new Error("Runtime evidence window has no versioned runtime rows");
       }
       const artifact = current.artifact;
-      const outPath = import_node_path29.default.resolve(projectRoot12, String(flags28.out));
-      await import_promises32.default.mkdir(import_node_path29.default.dirname(outPath), { recursive: true });
+      const outPath = import_node_path30.default.resolve(projectRoot12, String(flags28.out));
+      await import_promises32.default.mkdir(import_node_path30.default.dirname(outPath), { recursive: true });
       await import_promises32.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
       const published = publishDir ? await Promise.all(
         artifacts.map(
           ({ artifact: artifact2, composition }) => (0, runtimeEvidenceArtifacts_exports.publishRuntimeEvidenceBundle)({
-            publishRoot: import_node_path29.default.resolve(projectRoot12, publishDir),
+            publishRoot: import_node_path30.default.resolve(projectRoot12, publishDir),
             deploymentId,
             userName: String(flags28.user),
             startTime,
@@ -33345,11 +33484,11 @@ __export(runtimeEvidenceSync_exports, {
   main: () => main41,
   runtimeEvidenceSync: () => runtimeEvidenceSync
 });
-var import_node_path30, import_args32, import_chalk48, flags29, projectRoot13, runtimeEvidenceSync, main41;
+var import_node_path31, import_args32, import_chalk48, flags29, projectRoot13, runtimeEvidenceSync, main41;
 var init_runtimeEvidenceSync2 = __esm({
   "src/scripts/runtimeEvidenceSync.ts"() {
     "use strict";
-    import_node_path30 = __toESM(require("path"));
+    import_node_path31 = __toESM(require("path"));
     import_args32 = __toESM(require("args"));
     import_chalk48 = __toESM(require("chalk"));
     init_runtimeEvidenceSync();
@@ -33377,7 +33516,7 @@ var init_runtimeEvidenceSync2 = __esm({
           "Provide --source or RUNTIME_EVIDENCE_RSYNC_SOURCE for runtime evidence sync."
         );
       }
-      const evidenceRoot = import_node_path30.default.resolve(projectRoot13, String(flags29.dir));
+      const evidenceRoot = import_node_path31.default.resolve(projectRoot13, String(flags29.dir));
       const result = await syncRuntimeEvidenceBundles({
         source,
         evidenceRoot,
@@ -34415,26 +34554,43 @@ var init_monitoringProfile = __esm({
 });
 
 // src/lib/strategyRelease/evidenceRetention.ts
-var DAY_MS14, planStrategyEvidenceRetention;
+var DAY_MS14, isResearchRetired, planStrategyEvidenceRetention;
 var init_evidenceRetention = __esm({
   "src/lib/strategyRelease/evidenceRetention.ts"() {
     "use strict";
     DAY_MS14 = 864e5;
+    isResearchRetired = (research) => research?.status === "retired" && research.retirement?.policy === "discard-unrecoverable-without-rerun" && Boolean(research.retirement.reason.trim()) && Boolean(research.retirement.missingEvidence.length) && research.retirement.missingEvidence.every((item) => Boolean(item.trim()));
     planStrategyEvidenceRetention = ({
       now: now2,
       entries,
+      research,
       retentionDays = {
         operational_redis: 3,
         verbose_payload: 14,
+        research_payload: 0,
+        research_cache: 0,
         verified_runtime_bundle: 90,
         compact_ledger: null
       }
     }) => {
       const keep = [];
       const remove = [];
+      const retired = isResearchRetired(research);
+      const roles = new Set(
+        research?.permanentArtifacts.map((artifact) => artifact.role)
+      );
+      const terminalResearch = Boolean(
+        (research?.status === "completed" || retired) && Number.isFinite(research?.completedAt) && research.completedAt <= now2 && (retired ? ["note"] : ["note", "candidates", "metrics"]).every(
+          (role) => roles.has(role)
+        )
+      );
       for (const entry of entries) {
         const days = retentionDays[entry.kind];
-        if (days == null || !entry.verified || !entry.aggregated || now2 - entry.createdAt <= days * DAY_MS14) {
+        const isResearch = entry.kind === "research_payload" || entry.kind === "research_cache";
+        const completedResearch = Boolean(
+          terminalResearch && research?.researchId === entry.researchId && /^[a-f0-9]{64}$/.test(entry.sha256 ?? "")
+        );
+        if (isResearch && !completedResearch || days == null || !entry.verified || !entry.aggregated && !(isResearch && retired) || !isResearch && now2 - entry.createdAt <= days * DAY_MS14) {
           keep.push(entry);
         } else {
           remove.push(entry);
@@ -34611,13 +34767,13 @@ async function collectReleaseEvidenceReferences(references) {
     })
   );
 }
-var import_node_crypto15, import_promises33, import_node_path31, 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, safeSegment5, compactTimestamp, verifyFullPeriodChartArtifact, readVerifiedJsonArtifact, verifyResearchDecisionLineage, hasExactRuntimeTarget, deriveStrategyReleaseResearchDecision, canonicalStrategyReleaseJson, strategyReleaseSha256, assertFingerprint, assertLineageFingerprint, releaseReasons, deriveReleaseGates, verifyEvidenceComposition, createStrategyReleaseManifest, createStrategyReleaseEnvelope, verifyStrategyReleaseEnvelope, verifyStrategyEvidenceMarkerEnvelope, releaseMarkers, writeJsonAtomic2, publishStrategyRelease, publishStrategyLiveDiagnosis, finiteString3, finiteNumber7, finiteDirectionPolicy, uniqueStrings, incompleteEvidenceLineage, extractEvidenceLineage, verifyCompletedCoreResearchBundle;
+var import_node_crypto15, import_promises33, import_node_path32, 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, safeSegment5, compactTimestamp, verifyFullPeriodChartArtifact, readVerifiedJsonArtifact, verifyResearchDecisionLineage, hasExactRuntimeTarget, deriveStrategyReleaseResearchDecision, canonicalStrategyReleaseJson, strategyReleaseSha256, assertFingerprint, assertLineageFingerprint, releaseReasons, deriveReleaseGates, verifyEvidenceComposition, createStrategyReleaseManifest, createStrategyReleaseEnvelope, verifyStrategyReleaseEnvelope, verifyStrategyEvidenceMarkerEnvelope, releaseMarkers, writeJsonAtomic2, publishStrategyRelease, publishStrategyLiveDiagnosis, finiteString3, finiteNumber7, finiteDirectionPolicy, uniqueStrings, incompleteEvidenceLineage, extractEvidenceLineage, verifyCompletedCoreResearchBundle;
 var init_strategyRelease = __esm({
   "src/lib/strategyRelease.ts"() {
     "use strict";
     import_node_crypto15 = require("crypto");
     import_promises33 = __toESM(require("fs/promises"));
-    import_node_path31 = __toESM(require("path"));
+    import_node_path32 = __toESM(require("path"));
     import_types9 = require("@tradejs/types");
     import_strategyReleaseEvidence2 = require("@tradejs/infra/strategyReleaseEvidence");
     init_liveDiagnosis();
@@ -34636,7 +34792,7 @@ var init_strategyRelease = __esm({
       const artifact = input.chartArtifact;
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return false;
       try {
-        const artifactPath = import_node_path31.default.resolve(artifact.path);
+        const artifactPath = import_node_path32.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return false;
         }
@@ -34651,7 +34807,7 @@ var init_strategyRelease = __esm({
     readVerifiedJsonArtifact = async (artifact) => {
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return null;
       try {
-        const artifactPath = import_node_path31.default.resolve(artifact.path);
+        const artifactPath = import_node_path32.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return null;
         }
@@ -35314,7 +35470,7 @@ var init_strategyRelease = __esm({
     };
     writeJsonAtomic2 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises33.default.mkdir(import_node_path31.default.dirname(filePath), { recursive: true });
+      await import_promises33.default.mkdir(import_node_path32.default.dirname(filePath), { recursive: true });
       await import_promises33.default.writeFile(
         temporaryPath,
         `${canonicalStrategyReleaseJson(value)}
@@ -35338,13 +35494,13 @@ var init_strategyRelease = __esm({
           path: entry.path
         }))
       });
-      const releasePath = import_node_path31.default.join(
+      const releasePath = import_node_path32.default.join(
         rootDir,
         "releases",
         safeSegment5(manifest.strategy, "strategy"),
         `${manifest.releaseId}.json`
       );
-      const markerPath = import_node_path31.default.join(
+      const markerPath = import_node_path32.default.join(
         rootDir,
         "markers",
         safeSegment5(manifest.strategy, "strategy"),
@@ -35424,13 +35580,13 @@ var init_strategyRelease = __esm({
         markers,
         sourceArtifacts
       });
-      const diagnosisPath = import_node_path31.default.join(
+      const diagnosisPath = import_node_path32.default.join(
         rootDir,
         "diagnoses",
         safeSegment5(diagnosis.strategy, "strategy"),
         `${diagnosisId}.json`
       );
-      const markerPath = import_node_path31.default.join(
+      const markerPath = import_node_path32.default.join(
         rootDir,
         "markers",
         safeSegment5(diagnosis.strategy, "strategy"),
@@ -35620,9 +35776,9 @@ 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_path31.default.dirname(resultPath);
-      const manifestPath = import_node_path31.default.join(researchDir, "manifest.json");
-      const specPath = import_node_path31.default.join(researchDir, "spec.json");
+      const researchDir = import_node_path32.default.dirname(resultPath);
+      const manifestPath = import_node_path32.default.join(researchDir, "manifest.json");
+      const specPath = import_node_path32.default.join(researchDir, "spec.json");
       const manifestBytes = await import_promises33.default.readFile(manifestPath).catch(() => null);
       const specBytes = await import_promises33.default.readFile(specPath).catch(() => null);
       assert3(
@@ -35640,7 +35796,7 @@ var init_strategyRelease = __esm({
         artifactHashes ?? {}
       )) {
         assert3(
-          !import_node_path31.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
+          !import_node_path32.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
           `core bundle artifact ${relativePath} escapes its research directory`
         );
         assert3(
@@ -35648,7 +35804,7 @@ var init_strategyRelease = __esm({
           `core bundle artifact ${relativePath} has an invalid checksum`
         );
         const actualSha256 = await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(
-          import_node_path31.default.join(researchDir, relativePath)
+          import_node_path32.default.join(researchDir, relativePath)
         );
         assert3(
           actualSha256 === expectedSha256,
@@ -35665,13 +35821,13 @@ __export(runtimeScorecard_exports, {
   main: () => main42,
   runtimeScorecard: () => runtimeScorecard
 });
-var import_promises34, import_node_crypto16, import_node_path32, import_args33, import_chalk49, flags30, projectRoot14, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main42;
+var import_promises34, import_node_crypto16, import_node_path33, import_args33, import_chalk49, flags30, projectRoot14, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main42;
 var init_runtimeScorecard2 = __esm({
   "src/scripts/runtimeScorecard.ts"() {
     "use strict";
     import_promises34 = __toESM(require("fs/promises"));
     import_node_crypto16 = require("crypto");
-    import_node_path32 = __toESM(require("path"));
+    import_node_path33 = __toESM(require("path"));
     import_args33 = __toESM(require("args"));
     import_chalk49 = __toESM(require("chalk"));
     init_runtimeEvidenceArtifacts();
@@ -35741,7 +35897,7 @@ var init_runtimeScorecard2 = __esm({
     projectRoot14 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     resolveOptionalPath = (value) => {
       const raw = String(value ?? "").trim();
-      return raw ? import_node_path32.default.resolve(projectRoot14, raw) : null;
+      return raw ? import_node_path33.default.resolve(projectRoot14, raw) : null;
     };
     readJson = async (filePath) => filePath ? JSON.parse(await import_promises34.default.readFile(filePath, "utf8")) : void 0;
     assertReportType = (artifact, expected, label) => {
@@ -35820,9 +35976,9 @@ var init_runtimeScorecard2 = __esm({
         strategy: scorecardStrategy,
         llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
       });
-      const outPath = import_node_path32.default.resolve(projectRoot14, String(flags30.out));
+      const outPath = import_node_path33.default.resolve(projectRoot14, String(flags30.out));
       const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
-      await import_promises34.default.mkdir(import_node_path32.default.dirname(outPath), { recursive: true });
+      await import_promises34.default.mkdir(import_node_path33.default.dirname(outPath), { recursive: true });
       await Promise.all([
         import_promises34.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
@@ -35861,7 +36017,7 @@ var init_runtimeScorecard2 = __esm({
             composition: verifiedRelease?.manifest.composition,
             sourceArtifacts: await Promise.all(
               sourcePaths.map(async (sourcePath) => ({
-                artifactId: import_node_path32.default.basename(sourcePath),
+                artifactId: import_node_path33.default.basename(sourcePath),
                 path: sourcePath,
                 sha256: await sha256File2(sourcePath)
               }))
@@ -35872,11 +36028,11 @@ var init_runtimeScorecard2 = __esm({
       let receiptPath2 = null;
       if (flags30.markProcessed) {
         const runtimeEvidenceBundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(
-          import_node_path32.default.dirname(runtimeEvidencePath)
+          import_node_path33.default.dirname(runtimeEvidencePath)
         );
         const feedbackSource = replayEvidencePath ? await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplaySource)({
-          bundleDir: import_node_path32.default.dirname(replayEvidencePath),
-          runtimeEvidenceBundleDir: import_node_path32.default.dirname(runtimeEvidencePath)
+          bundleDir: import_node_path33.default.dirname(replayEvidencePath),
+          runtimeEvidenceBundleDir: import_node_path33.default.dirname(runtimeEvidencePath)
         }).catch((error) => {
           if (runtimeEvidenceBundle.artifact.producer) throw error;
           return null;
@@ -35887,9 +36043,9 @@ var init_runtimeScorecard2 = __esm({
           );
         }
         receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-          evidenceRoot: import_node_path32.default.resolve(projectRoot14, String(flags30.evidenceDir)),
+          evidenceRoot: import_node_path33.default.resolve(projectRoot14, String(flags30.evidenceDir)),
           deploymentId: String(flags30.deployment),
-          bundleDir: import_node_path32.default.dirname(runtimeEvidencePath),
+          bundleDir: import_node_path33.default.dirname(runtimeEvidencePath),
           scorecardPath: outPath,
           runtimeFeedback: feedbackSource ? {
             artifactId: feedbackSource.feedback.manifest.artifactId,
@@ -36080,21 +36236,316 @@ var init_runtimeControl = __esm({
   }
 });
 
+// src/lib/strategyRelease/researchFileConsumers.ts
+var import_node_path34, import_node_child_process10, import_node_util3, execFileAsync3, runCommand3, GUEST_FILE_CHECK, assertNoResearchFileConsumers;
+var init_researchFileConsumers = __esm({
+  "src/lib/strategyRelease/researchFileConsumers.ts"() {
+    "use strict";
+    import_node_path34 = __toESM(require("path"));
+    import_node_child_process10 = require("child_process");
+    import_node_util3 = require("util");
+    execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process10.execFile);
+    runCommand3 = (command, args39) => execFileAsync3(command, args39, { maxBuffer: 32 * 1024 * 1024 });
+    GUEST_FILE_CHECK = `
+import os, sys, json
+if os.geteuid() != 0:
+    raise RuntimeError('Cannot inspect every container process')
+wanted = set(json.loads(sys.argv[1]))
+opened = set()
+for pid in os.listdir('/proc'):
+    if not pid.isdigit():
+        continue
+    for kind in ('fd', 'map_files'):
+        directory = '/proc/' + pid + '/' + kind
+        try:
+            names = os.listdir(directory)
+        except FileNotFoundError:
+            continue
+        for name in names:
+            try:
+                target = os.readlink(directory + '/' + name)
+            except FileNotFoundError:
+                continue
+            if target in wanted:
+                opened.add(target)
+print(json.dumps(sorted(opened)))
+`;
+    assertNoResearchFileConsumers = async (files, run = runCommand3) => {
+      const virtualPids = /* @__PURE__ */ new Set();
+      const wanted = new Set(files.map((file) => import_node_path34.default.resolve(file)));
+      let commonRoot = files.length ? import_node_path34.default.dirname(files[0]) : "";
+      while (commonRoot && files.some((file) => {
+        const relative = import_node_path34.default.relative(commonRoot, file);
+        return relative === ".." || relative.startsWith(`..${import_node_path34.default.sep}`) || import_node_path34.default.isAbsolute(relative);
+      }))
+        commonRoot = import_node_path34.default.dirname(commonRoot);
+      const selectors = [];
+      if (files.length > 1e3 && commonRoot !== import_node_path34.default.parse(commonRoot).root) {
+        selectors.push(["+D", commonRoot]);
+      } else {
+        for (let offset = 0; offset < files.length; offset += 100)
+          selectors.push(["--", ...files.slice(offset, offset + 100)]);
+      }
+      for (const selector of selectors) {
+        let output;
+        try {
+          output = (await run("lsof", ["-F", "pcn", ...selector])).stdout;
+        } catch (error) {
+          if (error.code === 1) continue;
+          throw error;
+        }
+        let pid = "";
+        let virtual = false;
+        for (const line of output.split("\n")) {
+          if (line.startsWith("p")) {
+            pid = line.slice(1);
+            virtual = false;
+          }
+          if (line.startsWith("c"))
+            virtual = line.startsWith("ccom.apple.Virtualization.");
+          if (line.startsWith("n")) {
+            if (!wanted.has(import_node_path34.default.resolve(line.slice(1)))) continue;
+            if (!virtual || !/^\d+$/.test(pid))
+              throw new Error(
+                `Research cleanup found open files: ${line.slice(1)}`
+              );
+            virtualPids.add(pid);
+          }
+        }
+      }
+      if (!virtualPids.size) return;
+      for (const pid of virtualPids) {
+        const comm = (await run("ps", ["-p", pid, "-o", "comm="])).stdout.trim();
+        if (comm !== "/System/Library/Frameworks/Virtualization.framework/Versions/A/XPCServices/com.apple.Virtualization.VirtualMachine.xpc/Contents/MacOS/com.apple.Virtualization.VirtualMachine") {
+          throw new Error("Unrecognized virtual file consumer");
+        }
+      }
+      const contexts = JSON.parse(
+        (await run("docker", ["context", "inspect"])).stdout
+      );
+      if (contexts.length !== 1 || !contexts[0].Endpoints.docker.Host.startsWith("unix://")) {
+        throw new Error("Research file inspection requires a local Docker socket");
+      }
+      const ids = (await run("docker", ["ps", "-q"])).stdout.trim().split(/\s+/).filter(Boolean);
+      if (!ids.length)
+        throw new Error("Cannot resolve virtual research file handles");
+      const containers = JSON.parse(
+        (await run("docker", ["inspect", ...ids])).stdout
+      );
+      const covered = /* @__PURE__ */ new Set();
+      for (const container of containers) {
+        const guestFiles = /* @__PURE__ */ new Set();
+        for (const mount of container.Mounts) {
+          if (mount.Type !== "bind") continue;
+          for (const file of files) {
+            const relative = import_node_path34.default.relative(mount.Source, file);
+            if (relative === "" || !relative.startsWith(`..${import_node_path34.default.sep}`) && relative !== ".." && !import_node_path34.default.isAbsolute(relative)) {
+              guestFiles.add(import_node_path34.default.posix.join(mount.Destination, relative));
+              covered.add(file);
+            }
+          }
+        }
+        if (!guestFiles.size) continue;
+        const paths = [...guestFiles];
+        for (let offset = 0; offset < paths.length; offset += 250) {
+          const opened = JSON.parse(
+            (await run("docker", [
+              "exec",
+              container.Id,
+              "python",
+              "-c",
+              GUEST_FILE_CHECK,
+              JSON.stringify(paths.slice(offset, offset + 250))
+            ])).stdout
+          );
+          if (!Array.isArray(opened) || opened.length)
+            throw new Error("Research cleanup found open files in a container");
+        }
+      }
+      if (covered.size !== files.length)
+        throw new Error("Unresolved virtual research file handles");
+    };
+  }
+});
+
+// src/lib/strategyRelease/researchRetention.ts
+var import_promises35, import_node_path35, import_node_crypto17, import_strategyReleaseEvidence3, SHA256_RE3, mapFiles, fileSha256, inside, applyResearchRetention;
+var init_researchRetention = __esm({
+  "src/lib/strategyRelease/researchRetention.ts"() {
+    "use strict";
+    import_promises35 = __toESM(require("fs/promises"));
+    import_node_path35 = __toESM(require("path"));
+    import_node_crypto17 = require("crypto");
+    import_strategyReleaseEvidence3 = require("@tradejs/infra/strategyReleaseEvidence");
+    init_researchFileConsumers();
+    init_evidenceRetention();
+    SHA256_RE3 = /^[a-f0-9]{64}$/;
+    mapFiles = async (entries, visit) => {
+      const results2 = new Array(entries.length);
+      let next = 0;
+      const workers = await Promise.allSettled(
+        Array.from({ length: Math.min(8, entries.length) }, async () => {
+          while (next < entries.length) {
+            const index = next++;
+            results2[index] = await visit(entries[index]);
+          }
+        })
+      );
+      for (const worker of workers)
+        if (worker.status === "rejected") throw worker.reason;
+      return results2;
+    };
+    fileSha256 = async (file, bytes) => bytes <= 1024 * 1024 ? (0, import_node_crypto17.createHash)("sha256").update(await import_promises35.default.readFile(file)).digest("hex") : (0, import_strategyReleaseEvidence3.strategyEvidenceFileSha256)(file);
+    inside = (root, file) => {
+      const relative = import_node_path35.default.relative(root, file);
+      return relative !== "" && !relative.startsWith(`..${import_node_path35.default.sep}`) && relative !== ".." && !import_node_path35.default.isAbsolute(relative);
+    };
+    applyResearchRetention = async (options) => {
+      const projectRoot18 = await import_promises35.default.realpath(options.projectRoot);
+      const dataRoot = import_node_path35.default.join(projectRoot18, "data");
+      const resolve = (file) => import_node_path35.default.resolve(projectRoot18, file);
+      const receiptPath2 = resolve(options.receiptPath);
+      const journalPath = `${receiptPath2}.deleted.jsonl`;
+      const permanent = new Set(
+        options.research.permanentArtifacts.map((entry) => resolve(entry.path))
+      );
+      if (!inside(projectRoot18, receiptPath2) || permanent.has(receiptPath2) || permanent.has(journalPath)) {
+        throw new Error(
+          "Cleanup receipt must be separate from permanent research artifacts"
+        );
+      }
+      permanent.add(receiptPath2);
+      permanent.add(journalPath);
+      for (const file of options.protectedPaths ?? []) permanent.add(resolve(file));
+      const retired = isResearchRetired(options.research);
+      if (options.research.status !== "completed" && !retired || !Number.isFinite(options.research.completedAt) || options.research.completedAt > Date.now()) {
+        throw new Error("Research must be completed before cleanup");
+      }
+      for (const role of retired ? ["note"] : ["note", "candidates", "metrics"]) {
+        if (!options.research.permanentArtifacts.some((entry) => entry.role === role)) {
+          throw new Error(`Missing permanent research ${role}`);
+        }
+      }
+      await mapFiles(options.research.permanentArtifacts, async (artifact) => {
+        const file = resolve(artifact.path);
+        if (!inside(projectRoot18, await import_promises35.default.realpath(file)) || !SHA256_RE3.test(artifact.sha256) || await fileSha256(file, (await import_promises35.default.stat(file)).size) !== artifact.sha256) {
+          throw new Error(
+            `Permanent research artifact checksum/path mismatch: ${file}`
+          );
+        }
+        if (artifact.role === "note") {
+          const handle = await import_promises35.default.open(file, "r");
+          try {
+            const header = Buffer.alloc(4096);
+            const { bytesRead } = await handle.read(header, 0, header.length, 0);
+            const frontmatter = header.subarray(0, bytesRead).toString("utf8").match(/^---\r?\n([\s\S]*?)\r?\n---/);
+            if (!frontmatter || !/^schema:\s*tradejs-research\/v1\s*$/m.test(frontmatter[1]) || !(retired ? /^reproduction:\s*(?:complete|partial|blocked|legacy-partial)\s*$/m.test(
+              frontmatter[1]
+            ) : /^reproduction:\s*complete\s*$/m.test(frontmatter[1]))) {
+              throw new Error(
+                `Research note must have reproduction: complete: ${file}`
+              );
+            }
+          } finally {
+            await handle.close();
+          }
+        }
+      });
+      const checkedPaths = /* @__PURE__ */ new Set();
+      const checked = await mapFiles(options.entries, async (entry) => {
+        const file = resolve(entry.path);
+        if (!["research_payload", "research_cache"].includes(entry.kind) || entry.researchId !== options.research.researchId || !entry.verified || !entry.aggregated && !retired || !SHA256_RE3.test(entry.sha256 ?? "") || !inside(dataRoot, file) || permanent.has(file) || /\.(?:md|patch|diff)$/i.test(file)) {
+          throw new Error(`Not a disposable research file: ${file}`);
+        }
+        if (checkedPaths.has(file))
+          throw new Error(`Duplicate cleanup path: ${file}`);
+        checkedPaths.add(file);
+        if (await import_promises35.default.realpath(file) !== file)
+          throw new Error(`Research cleanup refuses symlinks: ${file}`);
+        const stat = await import_promises35.default.lstat(file);
+        if (!stat.isFile() || stat.size !== entry.bytes || await fileSha256(file, stat.size) !== entry.sha256) {
+          throw new Error(
+            `Disposable research file checksum/size mismatch: ${file}`
+          );
+        }
+        return { entry, file, mtimeMs: stat.mtimeMs, ino: stat.ino };
+      });
+      await assertNoResearchFileConsumers(checked.map((entry) => entry.file));
+      const receipt = {
+        schema: "tradejs-research-cleanup-receipt/v1",
+        researchId: options.research.researchId,
+        completedAt: options.research.completedAt,
+        ...retired ? { retirement: options.research.retirement } : {},
+        journalPath,
+        permanentArtifacts: options.research.permanentArtifacts,
+        scope: "reported aggregates and frozen candidates; new trade-level analyses require a rerun",
+        status: "planned",
+        files: checked.map(({ entry, file }) => ({
+          path: file,
+          sha256: entry.sha256,
+          bytes: entry.bytes,
+          removed: false
+        }))
+      };
+      if (!options.apply) return receipt;
+      await import_promises35.default.mkdir(import_node_path35.default.dirname(receiptPath2), { recursive: true });
+      if (await import_promises35.default.realpath(import_node_path35.default.dirname(receiptPath2)) !== import_node_path35.default.dirname(receiptPath2)) {
+        throw new Error("Cleanup receipt refuses symlinked directories");
+      }
+      const lock = await import_promises35.default.open(`${receiptPath2}.lock`, "wx");
+      let journal;
+      const writeReceipt = async () => {
+        const temp = `${receiptPath2}.${process.pid}.tmp`;
+        await import_promises35.default.writeFile(temp, `${JSON.stringify(receipt, null, 2)}
+`, "utf8");
+        await import_promises35.default.rename(temp, receiptPath2);
+      };
+      try {
+        journal = await import_promises35.default.open(journalPath, "wx");
+        receipt.status = "applying";
+        await writeReceipt();
+        for (let index = 0; index < checked.length; index += 1) {
+          const { file, entry, ino, mtimeMs } = checked[index];
+          const stat = await import_promises35.default.lstat(file);
+          if (!stat.isFile() || stat.ino !== ino || stat.mtimeMs !== mtimeMs || stat.size !== entry.bytes) {
+            throw new Error(`Research file changed during cleanup: ${file}`);
+          }
+          await import_promises35.default.unlink(file);
+          receipt.files[index].removed = true;
+          await journal.write(`${JSON.stringify(receipt.files[index])}
+`);
+        }
+        receipt.status = "completed";
+        await writeReceipt();
+        return receipt;
+      } catch (error) {
+        if (journal) await writeReceipt();
+        throw error;
+      } finally {
+        await journal?.close();
+        await lock.close();
+        await import_promises35.default.unlink(`${receiptPath2}.lock`);
+      }
+    };
+  }
+});
+
 // src/scripts/strategyRelease.ts
 var strategyRelease_exports = {};
 __export(strategyRelease_exports, {
   main: () => main44,
   runStrategyReleaseCommand: () => runStrategyReleaseCommand
 });
-var import_promises35, import_node_fs6, import_node_readline3, import_node_path33, import_chalk50, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main44;
+var import_promises36, import_node_fs6, import_node_readline3, import_node_path36, import_chalk50, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main44;
 var init_strategyRelease2 = __esm({
   "src/scripts/strategyRelease.ts"() {
     "use strict";
-    import_promises35 = __toESM(require("fs/promises"));
+    import_promises36 = __toESM(require("fs/promises"));
     import_node_fs6 = require("fs");
     import_node_readline3 = require("readline");
-    import_node_path33 = __toESM(require("path"));
+    import_node_path36 = __toESM(require("path"));
     import_chalk50 = __toESM(require("chalk"));
+    init_researchRetention();
     init_strategyRelease();
     valueAfter2 = (argv2, name) => {
       const index = argv2.indexOf(name);
@@ -36106,17 +36557,17 @@ var init_strategyRelease2 = __esm({
     };
     writeJsonAtomic3 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises35.default.mkdir(import_node_path33.default.dirname(filePath), { recursive: true });
-      await import_promises35.default.writeFile(
+      await import_promises36.default.mkdir(import_node_path36.default.dirname(filePath), { recursive: true });
+      await import_promises36.default.writeFile(
         temporaryPath,
         `${JSON.stringify(value, null, 2)}
 `,
         "utf8"
       );
-      await import_promises35.default.rename(temporaryPath, filePath);
+      await import_promises36.default.rename(temporaryPath, filePath);
     };
     runStrategyReleaseCommand = async (options) => {
-      const inputPath = import_node_path33.default.resolve(options.inputPath);
+      const inputPath = import_node_path36.default.resolve(options.inputPath);
       if (options.command === "verify") {
         const envelope = await verifyStrategyReleaseEnvelope(inputPath);
         return {
@@ -36154,7 +36605,7 @@ var init_strategyRelease2 = __esm({
           endTime,
           days: options.days?.length ? options.days : [7, 30, 90]
         });
-        const outputPath = import_node_path33.default.resolve(
+        const outputPath = import_node_path36.default.resolve(
           options.outputPath ?? "output/strategy-monitoring-profile.json"
         );
         await writeJsonAtomic3(outputPath, profile);
@@ -36165,22 +36616,40 @@ var init_strategyRelease2 = __esm({
           profile
         };
       }
-      const input = JSON.parse(await import_promises35.default.readFile(inputPath, "utf8"));
+      const input = JSON.parse(await import_promises36.default.readFile(inputPath, "utf8"));
       if (options.command === "decide") {
         const decision = await deriveStrategyReleaseResearchDecision(input);
         if (options.outputPath) {
-          await writeJsonAtomic3(import_node_path33.default.resolve(options.outputPath), decision);
+          await writeJsonAtomic3(import_node_path36.default.resolve(options.outputPath), decision);
         }
         return {
           kind: "decided",
           ...decision,
-          outputPath: options.outputPath ? import_node_path33.default.resolve(options.outputPath) : null
+          outputPath: options.outputPath ? import_node_path36.default.resolve(options.outputPath) : null
         };
       }
       if (options.command === "retention") {
         const plan = planStrategyEvidenceRetention(input);
-        if (options.apply) {
-          await Promise.all(plan.delete.map((entry) => import_promises35.default.rm(entry.path)));
+        const researchEntries = plan.delete.filter(
+          (entry) => entry.kind === "research_payload" || entry.kind === "research_cache"
+        );
+        const receiptPath2 = options.outputPath ?? `${inputPath}.receipt.json`;
+        if (researchEntries.length) {
+          if (researchEntries.length !== plan.delete.length) {
+            throw new Error(
+              "Research cleanup requires a separate inventory from runtime retention"
+            );
+          }
+          await applyResearchRetention({
+            projectRoot: process.env.PROJECT_CWD ?? process.cwd(),
+            research: input.research,
+            entries: researchEntries,
+            receiptPath: receiptPath2,
+            apply: Boolean(options.apply),
+            protectedPaths: [inputPath]
+          });
+        } else if (options.apply) {
+          await Promise.all(plan.delete.map((entry) => import_promises36.default.rm(entry.path)));
         }
         return {
           kind: "retention",
@@ -36188,17 +36657,18 @@ var init_strategyRelease2 = __esm({
           keepCount: plan.keep.length,
           deleteCount: plan.delete.length,
           bytesReclaimable: plan.bytesReclaimable,
-          delete: plan.delete.map((entry) => entry.path)
+          delete: plan.delete.map((entry) => entry.path),
+          ...researchEntries.length && options.apply ? { receiptPath: receiptPath2 } : {}
         };
       }
       if (options.command === "diagnose") {
         const diagnosis = buildStrategyLiveDiagnosis(input);
-        const outputPath = import_node_path33.default.resolve(
+        const outputPath = import_node_path36.default.resolve(
           options.outputPath ?? "output/strategy-live-diagnosis.json"
         );
         await writeJsonAtomic3(outputPath, diagnosis);
         const published2 = options.rootDir ? await publishStrategyLiveDiagnosis({
-          rootDir: import_node_path33.default.resolve(options.rootDir),
+          rootDir: import_node_path36.default.resolve(options.rootDir),
           diagnosis,
           sourceArtifacts: input.sourceArtifacts ?? []
         }) : null;
@@ -36215,7 +36685,7 @@ var init_strategyRelease2 = __esm({
         evidence: await collectReleaseEvidenceReferences(input.evidence ?? [])
       });
       const published = await publishStrategyRelease({
-        rootDir: import_node_path33.default.resolve(options.rootDir ?? "data/strategy-release"),
+        rootDir: import_node_path36.default.resolve(options.rootDir ?? "data/strategy-release"),
         manifest
       });
       return {
@@ -36275,12 +36745,12 @@ __export(serverHealth_exports, {
   main: () => main45,
   resolveServerHealthThresholds: () => resolveServerHealthThresholds
 });
-var import_config10, import_node_child_process10, import_node_os3, import_node_fs7, import_args34, import_redis20, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml6, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main45;
+var import_config10, import_node_child_process11, import_node_os3, import_node_fs7, import_args34, import_redis20, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml6, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main45;
 var init_serverHealth = __esm({
   "src/scripts/serverHealth.ts"() {
     "use strict";
     import_config10 = require("dotenv/config");
-    import_node_child_process10 = require("child_process");
+    import_node_child_process11 = require("child_process");
     import_node_os3 = __toESM(require("os"));
     import_node_fs7 = require("fs");
     import_args34 = __toESM(require("args"));
@@ -36317,21 +36787,21 @@ var init_serverHealth = __esm({
       }
       return `${minutes}m`;
     };
-    readDiskUsage = (path44) => {
+    readDiskUsage = (path47) => {
       try {
-        const stats = (0, import_node_fs7.statfsSync)(path44);
+        const stats = (0, import_node_fs7.statfsSync)(path47);
         const totalBlocks = Number(stats.blocks ?? 0);
         const availableBlocks = Number(stats.bavail ?? 0);
         if (totalBlocks <= 0) {
-          return { path: path44, usedPct: null };
+          return { path: path47, usedPct: null };
         }
         const usedPct = (totalBlocks - Math.max(0, availableBlocks)) / totalBlocks * 100;
         return {
-          path: path44,
+          path: path47,
           usedPct: Number.isFinite(usedPct) ? usedPct : null
         };
       } catch {
-        return { path: path44, usedPct: null };
+        return { path: path47, usedPct: null };
       }
     };
     parseMeminfoBytes = (value) => {
@@ -36396,7 +36866,7 @@ var init_serverHealth = __esm({
       }
     };
     runDiagnosticCommand = (command, args39) => {
-      const output = (0, import_node_child_process10.execFileSync)(command, args39, {
+      const output = (0, import_node_child_process11.execFileSync)(command, args39, {
         encoding: "utf8",
         timeout: 5e3,
         maxBuffer: 1024 * 1024,
@@ -38083,12 +38553,12 @@ __export(runtimeParity_exports, {
   main: () => main46,
   runtimeParity: () => runtimeParity
 });
-var import_config11, import_node_crypto17, import_args35, import_chalk52, import_constants19, import_time13, import_logger7, import_redis21, import_cli12, import_backtest7, import_connectors15, flags31, interval3, projectRoot16, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main46;
+var import_config11, import_node_crypto18, import_args35, import_chalk52, import_constants19, import_time13, import_logger7, import_redis21, import_cli12, import_backtest7, import_connectors15, flags31, interval3, projectRoot16, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main46;
 var init_runtimeParity2 = __esm({
   "src/scripts/runtimeParity.ts"() {
     "use strict";
     import_config11 = require("dotenv/config");
-    import_node_crypto17 = require("crypto");
+    import_node_crypto18 = require("crypto");
     import_args35 = __toESM(require("args"));
     import_chalk52 = __toESM(require("chalk"));
     import_constants19 = require("@tradejs/core/constants");
@@ -38471,9 +38941,9 @@ var init_runtimeParity2 = __esm({
                 start: window.start,
                 end: window.end
               },
-              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto17.randomUUID)().slice(0, 8)}`,
-              testId: (0, import_node_crypto17.randomUUID)().slice(0, 8),
-              testSuiteId: (0, import_node_crypto17.randomUUID)().slice(0, 8),
+              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto18.randomUUID)().slice(0, 8)}`,
+              testId: (0, import_node_crypto18.randomUUID)().slice(0, 8),
+              testSuiteId: (0, import_node_crypto18.randomUUID)().slice(0, 8),
               strategyName: target.strategy,
               strategyConfig: replayConfig,
               connectorName,