pandora-cli-skills 1.1.31 → 1.1.32

package/cli/lib/mirror_sync/execution.cjs

@@ -0,0 +1,331 @@
+const { saveState, pruneIdempotencyKeys } = require('../mirror_state_store.cjs');
+const { readTradingCredsFromEnv } = require('../polymarket_trade_adapter.cjs');
+const { toNumber, round } = require('../shared/utils.cjs');
+
+function buildIdempotencyKey(options, snapshot, nowMs) {
+  const bucketSize = Math.max(1_000, Number(options.cooldownMs) || 60_000);
+  const bucket = Math.floor(nowMs / bucketSize);
+  const metrics = snapshot && snapshot.metrics ? snapshot.metrics : {};
+  const actionPlan = snapshot && snapshot.actionPlan ? snapshot.actionPlan : {};
+  const rebalanceUsdc = Math.round((toNumber(actionPlan.rebalanceUsdc) || 0) * 100) / 100;
+  const hedgeUsdc = Math.round((toNumber(actionPlan.hedgeUsdc) || 0) * 100) / 100;
+
+  return [
+    String(options.pandoraMarketAddress || '').toLowerCase(),
+    String(options.polymarketMarketId || options.polymarketSlug || '').toLowerCase(),
+    metrics.driftTriggered ? 'drift' : 'no-drift',
+    metrics.hedgeTriggered ? 'hedge' : 'no-hedge',
+    actionPlan.rebalanceSide || 'rebalance:none',
+    actionPlan.hedgeTokenSide || 'hedge:none',
+    String(rebalanceUsdc),
+    String(hedgeUsdc),
+    String(bucket),
+  ].join('|');
+}
+
+/**
+ * Create an executable action envelope for a triggered tick.
+ * @param {{options: object, idempotencyKey: string, gate: object}} params
+ * @returns {object}
+ */
+function buildExecutableAction(params) {
+  const { options, idempotencyKey, gate } = params;
+  return {
+    mode: options.executeLive ? 'live' : 'paper',
+    status: options.executeLive ? 'executed' : 'simulated',
+    idempotencyKey,
+    forcedGateBypass: gate.bypassedFailedChecks.length > 0,
+    failedChecks: gate.failedChecks,
+    failedChecksRaw: gate.failedChecksRaw,
+    bypassedFailedChecks: gate.bypassedFailedChecks,
+    rebalance: null,
+    hedge: null,
+  };
+}
+
+/**
+ * Normalize thrown execution errors into service result payloads.
+ * @param {any} err
+ * @returns {{ok: false, error: {code: string|null, message: string}}}
+ */
+function normalizeExecutionFailure(err) {
+  return {
+    ok: false,
+    error: {
+      code: err && err.code ? String(err.code) : null,
+      message: err && err.message ? String(err.message) : String(err),
+    },
+  };
+}
+
+/**
+ * Execute or simulate rebalance leg and mutate action/state accordingly.
+ * @param {{options: object, action: object, plan: object, snapshotMetrics: object, rebalanceFn: Function, state: object}} params
+ * @returns {Promise<number>} Executed rebalance notional in USDC.
+ */
+async function executeRebalanceLeg(params) {
+  const { options, action, plan, snapshotMetrics, rebalanceFn, state } = params;
+  if (!(snapshotMetrics.driftTriggered && plan.plannedRebalanceUsdc > 0)) return 0;
+
+  let rebalanceResultOk = true;
+  if (options.executeLive) {
+    let rebalanceResult;
+    try {
+      rebalanceResult = await rebalanceFn({
+        marketAddress: options.pandoraMarketAddress,
+        side: plan.rebalanceSide,
+        amountUsdc: plan.plannedRebalanceUsdc,
+      });
+    } catch (err) {
+      rebalanceResult = normalizeExecutionFailure(err);
+    }
+    action.rebalance = {
+      side: plan.rebalanceSide,
+      amountUsdc: plan.plannedRebalanceUsdc,
+      result: rebalanceResult,
+    };
+    rebalanceResultOk = Boolean(rebalanceResult && rebalanceResult.ok !== false);
+  } else {
+    action.rebalance = {
+      side: plan.rebalanceSide,
+      amountUsdc: plan.plannedRebalanceUsdc,
+      result: { status: 'simulated' },
+    };
+  }
+
+  if (rebalanceResultOk) {
+    state.cumulativeLpFeesApproxUsdc =
+      round((toNumber(state.cumulativeLpFeesApproxUsdc) || 0) + plan.plannedRebalanceUsdc * 0.003, 6) || 0;
+    return plan.plannedRebalanceUsdc;
+  }
+
+  action.status = 'failed';
+  const rebalanceError =
+    action.rebalance && action.rebalance.result && action.rebalance.result.error
+      ? action.rebalance.result.error
+      : { message: 'Pandora rebalance execution failed.' };
+  action.error = {
+    code: 'REBALANCE_EXECUTION_FAILED',
+    message: rebalanceError.message || 'Pandora rebalance execution failed.',
+    details: rebalanceError,
+  };
+  return 0;
+}
+
+/**
+ * Execute or simulate hedge leg and mutate action/state accordingly.
+ * @param {{options: object, action: object, plan: object, verifyPayload: object, depth: object, hedgeFn: Function, state: object}} params
+ * @returns {Promise<number>} Executed hedge notional in USDC.
+ */
+async function executeHedgeLeg(params) {
+  const { options, action, plan, verifyPayload, depth, hedgeFn, state } = params;
+  if (!(plan.hedgeTriggered && plan.plannedHedgeUsdc > 0)) return 0;
+
+  const hedgeSide = 'buy';
+  const tokenId = plan.gapUsdc >= 0 ? verifyPayload.sourceMarket.yesTokenId : verifyPayload.sourceMarket.noTokenId;
+  const hedgeDepth = plan.gapUsdc >= 0 ? depth.yesDepth : depth.noDepth;
+
+  if (options.executeLive) {
+    const envCreds = readTradingCredsFromEnv();
+    let hedgeResult;
+    if (!options.privateKey && envCreds.privateKeyInvalid) {
+      hedgeResult = {
+        ok: false,
+        error: {
+          code: 'INVALID_ENV',
+          message: 'POLYMARKET_PRIVATE_KEY must be a valid private key (0x + 64 hex chars).',
+        },
+      };
+    } else {
+      try {
+        hedgeResult = await hedgeFn({
+          host: options.polymarketHost,
+          mockUrl: options.polymarketMockUrl,
+          tokenId,
+          side: hedgeSide,
+          amountUsd: plan.plannedHedgeUsdc,
+          privateKey: options.privateKey || envCreds.privateKey,
+          funder: options.funder || envCreds.funder,
+          apiKey: envCreds.apiKey,
+          apiSecret: envCreds.apiSecret,
+          apiPassphrase: envCreds.apiPassphrase,
+        });
+      } catch (err) {
+        hedgeResult = normalizeExecutionFailure(err);
+      }
+    }
+    action.hedge = {
+      tokenId,
+      side: hedgeSide,
+      amountUsdc: plan.plannedHedgeUsdc,
+      result: hedgeResult,
+    };
+  } else {
+    action.hedge = {
+      tokenId,
+      side: hedgeSide,
+      amountUsdc: plan.plannedHedgeUsdc,
+      result: { status: 'simulated' },
+    };
+  }
+
+  const hedgeResultOk = !options.executeLive || (action.hedge && action.hedge.result && action.hedge.result.ok !== false);
+  if (hedgeResultOk) {
+    const direction = plan.gapUsdc >= 0 ? 1 : -1;
+    state.currentHedgeUsdc =
+      round((toNumber(state.currentHedgeUsdc) || 0) + direction * plan.plannedHedgeUsdc, 6) || 0;
+    state.cumulativeHedgeNotionalUsdc =
+      round((toNumber(state.cumulativeHedgeNotionalUsdc) || 0) + plan.plannedHedgeUsdc, 6) || 0;
+    const slippageRatio =
+      hedgeDepth && hedgeDepth.midPrice !== null && hedgeDepth.worstPrice !== null && hedgeDepth.midPrice > 0
+        ? Math.max(0, Math.abs(hedgeDepth.worstPrice - hedgeDepth.midPrice) / hedgeDepth.midPrice)
+        : 0;
+    const hedgeCostApprox = plan.plannedHedgeUsdc * slippageRatio;
+    state.cumulativeHedgeCostApproxUsdc =
+      round((toNumber(state.cumulativeHedgeCostApproxUsdc) || 0) + hedgeCostApprox, 6) || 0;
+    return plan.plannedHedgeUsdc;
+  }
+
+  action.status = 'failed';
+  const hedgeError =
+    action.hedge && action.hedge.result && action.hedge.result.error
+      ? action.hedge.result.error
+      : action.hedge && action.hedge.result && action.hedge.result.response && action.hedge.result.response.error
+        ? { message: String(action.hedge.result.response.error) }
+        : { message: 'Polymarket hedge execution failed.' };
+  action.error = {
+    code: 'HEDGE_EXECUTION_FAILED',
+    message: hedgeError.message || 'Polymarket hedge execution failed.',
+    details: hedgeError,
+  };
+  return 0;
+}
+
+/**
+ * Apply executed leg totals to persistent state.
+ * @param {{state: object, action: object, idempotencyKey: string, actualRebalanceUsdc: number, actualHedgeUsdc: number}} params
+ * @returns {void}
+ */
+function finalizeExecutedActionState(params) {
+  const { state, action, idempotencyKey, actualRebalanceUsdc, actualHedgeUsdc } = params;
+  const actualSpendUsdc = round(actualRebalanceUsdc + actualHedgeUsdc, 6) || 0;
+  state.dailySpendUsdc = round((toNumber(state.dailySpendUsdc) || 0) + actualSpendUsdc, 6) || 0;
+  const executedLegCount = (actualRebalanceUsdc > 0 ? 1 : 0) + (actualHedgeUsdc > 0 ? 1 : 0);
+  if (executedLegCount > 0) {
+    state.idempotencyKeys.push(idempotencyKey);
+    pruneIdempotencyKeys(state);
+  }
+  state.tradesToday += executedLegCount;
+  state.lastExecution = action;
+}
+
+/**
+ * Execute triggered action path (skip/blocked/executed) for a tick.
+ * @param {{options: object, state: object, snapshot: object, plan: object, gate: object, tickAt: Date, loadedFilePath: string, rebalanceFn: Function, hedgeFn: Function, sendWebhook: Function|null, strategyHash: string, iteration: number, actions: Array<object>, webhookReports: Array<object>, snapshotMetrics: object, verifyPayload: object, depth: object}} params
+ * @returns {Promise<void>}
+ */
+async function processTriggeredAction(params) {
+  const {
+    options,
+    state,
+    snapshot,
+    plan,
+    gate,
+    tickAt,
+    loadedFilePath,
+    rebalanceFn,
+    hedgeFn,
+    sendWebhook,
+    strategyHash: hash,
+    iteration,
+    actions,
+    webhookReports,
+    snapshotMetrics,
+    verifyPayload,
+    depth,
+  } = params;
+
+  const idempotencyKey = buildIdempotencyKey(options, snapshot, tickAt.getTime());
+  if ((state.idempotencyKeys || []).includes(idempotencyKey)) {
+    snapshot.action = {
+      mode: options.executeLive ? 'live' : 'paper',
+      status: 'skipped',
+      reason: 'Duplicate trigger bucket (idempotency key already processed).',
+      idempotencyKey,
+    };
+    return;
+  }
+
+  if (!gate.ok) {
+    snapshot.action = {
+      mode: options.executeLive ? 'live' : 'paper',
+      status: 'blocked',
+      reason: 'Strict gate blocked execution.',
+      idempotencyKey,
+      failedChecks: gate.failedChecks,
+      failedChecksRaw: gate.failedChecksRaw,
+      bypassedFailedChecks: gate.bypassedFailedChecks,
+    };
+    return;
+  }
+
+  const action = buildExecutableAction({ options, idempotencyKey, gate });
+  state.lastExecution = {
+    mode: action.mode,
+    status: 'pending',
+    idempotencyKey,
+    startedAt: tickAt.toISOString(),
+  };
+  saveState(loadedFilePath, state);
+
+  const actualRebalanceUsdc = await executeRebalanceLeg({
+    options,
+    action,
+    plan,
+    snapshotMetrics,
+    rebalanceFn,
+    state,
+  });
+  const actualHedgeUsdc = await executeHedgeLeg({
+    options,
+    action,
+    plan,
+    verifyPayload,
+    depth,
+    hedgeFn,
+    state,
+  });
+
+  finalizeExecutedActionState({
+    state,
+    action,
+    idempotencyKey,
+    actualRebalanceUsdc,
+    actualHedgeUsdc,
+  });
+
+  snapshot.action = action;
+  actions.push(action);
+
+  if (sendWebhook) {
+    const report = await sendWebhook({
+      event: 'mirror.sync.trigger',
+      strategyHash: hash,
+      iteration,
+      message: `[Pandora Mirror] action=${action.status} drift=${snapshotMetrics.driftBps} hedgeGap=${plan.gapUsdc}`,
+      action,
+      snapshot,
+    });
+    webhookReports.push(report);
+  }
+}
+
+module.exports = {
+  buildIdempotencyKey,
+  buildExecutableAction,
+  normalizeExecutionFailure,
+  executeRebalanceLeg,
+  executeHedgeLeg,
+  finalizeExecutedActionState,
+  processTriggeredAction,
+};

package/cli/lib/mirror_sync/gates.cjs

@@ -0,0 +1,282 @@
+const { toNumber, round } = require('../shared/utils.cjs');
+
+const MIRROR_SYNC_GATE_CODES = Object.freeze([
+  'MATCH_AND_RULES',
+  'POLYMARKET_SOURCE_FRESH',
+  'CLOSE_TIME_DELTA',
+  'DEPTH_COVERAGE',
+  'MAX_OPEN_EXPOSURE',
+  'MAX_TRADES_PER_DAY',
+  'MIN_TIME_TO_EXPIRY',
+]);
+
+/**
+ * Read min-time-to-expiry from verify payload in seconds.
+ * @param {object} verifyPayload
+ * @returns {number|null}
+ */
+function readMinTimeToExpirySec(verifyPayload) {
+  return verifyPayload && verifyPayload.expiry && Number.isFinite(Number(verifyPayload.expiry.minTimeToExpirySec))
+    ? Number(verifyPayload.expiry.minTimeToExpirySec)
+    : null;
+}
+
+/**
+ * Derive sync metrics from verification payloads.
+ * `driftBps` is in basis points; reserve/delta/hedge fields are decimal USDC.
+ * @param {object} verifyPayload
+ * @param {{driftTriggerBps: number}} options
+ * @returns {{
+ *   sourceYesPct: number|null,
+ *   pandoraYesPct: number|null,
+ *   driftBps: number|null,
+ *   driftTriggered: boolean,
+ *   reserveYesUsdc: number|null,
+ *   reserveNoUsdc: number|null,
+ *   reserveTotalUsdc: number|null,
+ *   deltaLpUsdc: number|null,
+ *   targetHedgeUsdc: number|null,
+ *   minTimeToExpirySec: number|null
+ * }}
+ */
+function evaluateSnapshot(verifyPayload, options) {
+  const pandora = verifyPayload.pandora || {};
+  const source = verifyPayload.sourceMarket || {};
+
+  const sourceYes = toNumber(source.yesPct);
+  const pandoraYes = toNumber(pandora.yesPct);
+
+  const driftBps = sourceYes !== null && pandoraYes !== null ? Math.abs(sourceYes - pandoraYes) * 100 : null;
+  const driftTriggered = driftBps !== null && driftBps >= options.driftTriggerBps;
+
+  const reserveYes = toNumber(pandora.reserveYes);
+  const reserveNo = toNumber(pandora.reserveNo);
+  const reserveTotalUsdc = reserveYes !== null && reserveNo !== null ? round(reserveYes + reserveNo, 6) : null;
+  const deltaLpUsdc = reserveYes !== null && reserveNo !== null ? round(reserveYes - reserveNo, 6) : null;
+  const targetHedgeUsdc = deltaLpUsdc === null ? null : round(-deltaLpUsdc, 6);
+  const minTimeToExpirySec = readMinTimeToExpirySec(verifyPayload);
+
+  return {
+    sourceYesPct: sourceYes,
+    pandoraYesPct: pandoraYes,
+    driftBps,
+    driftTriggered,
+    reserveYesUsdc: reserveYes,
+    reserveNoUsdc: reserveNo,
+    reserveTotalUsdc,
+    deltaLpUsdc,
+    targetHedgeUsdc,
+    minTimeToExpirySec,
+  };
+}
+
+/**
+ * Evaluate hard execution gates before submitting live sync actions.
+ * @param {object} context
+ * @returns {{ok: boolean, failedChecks: string[], checks: Array<{code: string, ok: boolean, message: string, details: any}>}}
+ */
+function evaluateStrictGates(context) {
+  const failures = [];
+  const checks = [];
+
+  const add = (code, ok, message, details = null) => {
+    checks.push({ code, ok, message, details });
+    if (!ok) failures.push(code);
+  };
+
+  const verify = context.verifyPayload;
+  const verifyGate = verify && verify.gateResult ? verify.gateResult : null;
+  add('MATCH_AND_RULES', Boolean(verifyGate && verifyGate.ok), 'Mirror match/rules gates must pass.', {
+    failedChecks: verifyGate ? verifyGate.failedChecks : ['UNKNOWN'],
+  });
+
+  const sourceType = String((verify && verify.sourceMarket && verify.sourceMarket.source) || '').toLowerCase();
+  const sourceIsCached = sourceType === 'polymarket:cache';
+  add(
+    'POLYMARKET_SOURCE_FRESH',
+    context.executeLive ? !sourceIsCached : true,
+    'Live mode requires fresh Polymarket source data (cached source is blocked).',
+    {
+      sourceType: sourceType || null,
+    },
+  );
+
+  const closeDeltaCheck =
+    verifyGate && Array.isArray(verifyGate.checks)
+      ? verifyGate.checks.find((item) => item.code === 'CLOSE_TIME_DELTA')
+      : null;
+  add(
+    'CLOSE_TIME_DELTA',
+    closeDeltaCheck ? closeDeltaCheck.ok : true,
+    'Close-time delta must be within strict threshold.',
+    closeDeltaCheck && closeDeltaCheck.meta ? closeDeltaCheck.meta : null,
+  );
+
+  const depthRequired = toNumber(context.plannedHedgeUsdc) || 0;
+  const explicitHedgeDepth = toNumber(context.hedgeDepthWithinSlippageUsd);
+  const depthAvailable = explicitHedgeDepth === null ? toNumber(context.depthWithinSlippageUsd) || 0 : explicitHedgeDepth;
+  add(
+    'DEPTH_COVERAGE',
+    depthRequired <= 0 ? true : depthAvailable >= depthRequired,
+    'Source depth must cover hedge notional at configured slippage.',
+    {
+      depthRequired,
+      depthAvailable,
+      slippageBps: context.depthSlippageBps,
+    },
+  );
+
+  const state = context.state;
+  const postTradeHedgeExposure = Math.abs(
+    (toNumber(state.currentHedgeUsdc) || 0) + (toNumber(context.plannedHedgeSignedUsdc) || 0),
+  );
+  const maxExposure = toNumber(context.maxOpenExposureUsdc);
+  add(
+    'MAX_OPEN_EXPOSURE',
+    maxExposure === null ? true : postTradeHedgeExposure <= maxExposure,
+    'Max open exposure must not be exceeded.',
+    {
+      postTradeHedgeExposure: round(postTradeHedgeExposure, 6),
+      maxOpenExposureUsdc: maxExposure,
+    },
+  );
+
+  add(
+    'MAX_TRADES_PER_DAY',
+    (toNumber(state.tradesToday) || 0) < context.maxTradesPerDay,
+    'Daily trade cap must allow another execution.',
+    {
+      tradesToday: state.tradesToday,
+      maxTradesPerDay: context.maxTradesPerDay,
+    },
+  );
+
+  add(
+    'MIN_TIME_TO_EXPIRY',
+    context.minTimeToExpirySec === null ? true : context.minTimeToExpirySec >= context.minimumTimeToCloseSec,
+    `Minimum time-to-expiry must be >= ${context.minimumTimeToCloseSec}s for sync runtime.`,
+    {
+      minTimeToExpirySec: context.minTimeToExpirySec,
+      minimumTimeToCloseSec: context.minimumTimeToCloseSec,
+    },
+  );
+
+  return {
+    ok: failures.length === 0,
+    failedChecks: failures,
+    checks,
+  };
+}
+
+function normalizeSkipGateChecks(rawChecks) {
+  if (!Array.isArray(rawChecks)) return [];
+  const allowed = new Set(MIRROR_SYNC_GATE_CODES);
+  return Array.from(
+    new Set(
+      rawChecks
+        .map((value) => String(value || '').trim().toUpperCase())
+        .filter((value) => value && allowed.has(value)),
+    ),
+  );
+}
+
+function applyGateBypassPolicy(gate, options) {
+  const failedChecksRaw = Array.isArray(gate && gate.failedChecks) ? [...gate.failedChecks] : [];
+  const forceGate = Boolean(options && options.forceGate);
+  const skipGateChecks = forceGate ? [] : normalizeSkipGateChecks(options && options.skipGateChecks);
+  const skipSet = new Set(skipGateChecks);
+  const bypassedFailedChecks = forceGate
+    ? failedChecksRaw
+    : failedChecksRaw.filter((code) => skipSet.has(code));
+  const failedChecks = forceGate
+    ? []
+    : failedChecksRaw.filter((code) => !skipSet.has(code));
+
+  return {
+    ...(gate || { checks: [] }),
+    ok: failedChecks.length === 0,
+    failedChecks,
+    failedChecksRaw,
+    bypassedFailedChecks,
+    skipGateChecksApplied: forceGate ? ['*'] : skipGateChecks,
+    forceGate,
+  };
+}
+
+/**
+ * Resolve runtime minimum time-to-close guard in seconds.
+ * @param {object} options
+ * @returns {number}
+ */
+function resolveMinimumTimeToCloseSec(options) {
+  const configuredMinTimeToCloseSec = Number.isInteger(Number(options.minTimeToCloseSec))
+    ? Math.max(60, Math.trunc(Number(options.minTimeToCloseSec)))
+    : 1800;
+  return Math.max(
+    Math.ceil((options.intervalMs || 5_000) / 1000) * 2,
+    configuredMinTimeToCloseSec,
+  );
+}
+
+/**
+ * Build strict-gate evaluation context for a tick.
+ * @param {{verifyPayload: object, options: object, state: object, plan: object, snapshotMetrics: object, depth: object, minimumTimeToCloseSec: number}} params
+ * @returns {object}
+ */
+function buildTickGateContext(params) {
+  const { verifyPayload, options, state, plan, snapshotMetrics, depth, minimumTimeToCloseSec } = params;
+  return {
+    verifyPayload,
+    executeLive: options.executeLive,
+    state,
+    plannedHedgeUsdc: plan.plannedHedgeUsdc,
+    plannedSpendUsdc: plan.plannedSpendUsdc,
+    plannedHedgeSignedUsdc: plan.plannedHedgeSignedUsdc,
+    minTimeToExpirySec: snapshotMetrics.minTimeToExpirySec,
+    minimumTimeToCloseSec,
+    depthWithinSlippageUsd: depth.depthWithinSlippageUsd,
+    hedgeDepthWithinSlippageUsd:
+      plan.plannedHedgeUsdc > 0
+        ? plan.gapUsdc >= 0
+          ? depth.yesDepth && depth.yesDepth.depthUsd
+          : depth.noDepth && depth.noDepth.depthUsd
+        : null,
+    depthSlippageBps: options.depthSlippageBps,
+    maxOpenExposureUsdc: options.maxOpenExposureUsdc,
+    maxTradesPerDay: options.maxTradesPerDay,
+  };
+}
+
+/**
+ * Verify mirror pair once at startup and enforce expiry guard.
+ * @param {{verifyFn: Function, options: object, minimumTimeToCloseSec: number, buildVerifyRequest: Function, createServiceError: Function}} params
+ * @returns {Promise<object>}
+ */
+async function runStartupVerify(params) {
+  const { verifyFn, options, minimumTimeToCloseSec, buildVerifyRequest, createServiceError } = params;
+  const payload = await verifyFn(buildVerifyRequest(options));
+  const startupMinTime = readMinTimeToExpirySec(payload);
+  if (startupMinTime !== null && startupMinTime < minimumTimeToCloseSec) {
+    throw createServiceError(
+      'MIRROR_EXPIRY_TOO_CLOSE',
+      `Mirror sync refused to start because market expiry is too close (${startupMinTime}s < ${minimumTimeToCloseSec}s).`,
+      {
+        startupMinTimeToExpirySec: startupMinTime,
+        minimumTimeToCloseSec,
+      },
+    );
+  }
+  return payload;
+}
+
+module.exports = {
+  MIRROR_SYNC_GATE_CODES,
+  readMinTimeToExpirySec,
+  evaluateSnapshot,
+  evaluateStrictGates,
+  normalizeSkipGateChecks,
+  applyGateBypassPolicy,
+  resolveMinimumTimeToCloseSec,
+  buildTickGateContext,
+  runStartupVerify,
+};