@idlekit/cli 0.5.1 → 0.6.0

package/dist/main.js

@@ -11605,6 +11605,63 @@ function logicalDrawId(drawIndex) {
   return String(drawIndex);
 }
 
+// ../core/dist/sim/sessionOffline.js
+function validateCreditPolicy(policy) {
+  if (!policy || typeof policy !== "object" || Array.isArray(policy) || "actions" in policy) {
+    throw new RangeError("prepareOffline policy must be a credit policy; set actions on scenario.run.offline");
+  }
+  if (policy.maxSec !== undefined && (typeof policy.maxSec !== "number" || !Number.isFinite(policy.maxSec) || policy.maxSec < 0)) {
+    throw new RangeError("prepareOffline policy.maxSec must be finite and nonnegative");
+  }
+  if (policy.overflowPolicy !== undefined && policy.overflowPolicy !== "clamp" && policy.overflowPolicy !== "reject") {
+    throw new RangeError("prepareOffline policy.overflowPolicy must be clamp or reject");
+  }
+  const decay = policy.decay;
+  if (decay !== undefined) {
+    if (!decay || typeof decay !== "object" || Array.isArray(decay) || decay.kind !== "none" && decay.kind !== "linear") {
+      throw new RangeError("prepareOffline policy.decay must select none or linear");
+    }
+    if (decay.floorRatio !== undefined && (typeof decay.floorRatio !== "number" || !Number.isFinite(decay.floorRatio) || decay.floorRatio < 0 || decay.floorRatio > 1)) {
+      throw new RangeError("prepareOffline policy.decay.floorRatio must be finite and in 0..1");
+    }
+  }
+}
+function prepareOfflineSegment(args) {
+  const { scenario, prepare } = args;
+  if (!prepare)
+    return { model: scenario.model, policy: scenario.run.offline, stepSec: scenario.run.stepSec };
+  const prepared = prepare({
+    ctx: scenario.ctx,
+    model: scenario.model,
+    state: deepClonePreservingPrototype(args.state),
+    seconds: args.seconds,
+    wallStartT: args.wallStartT,
+    wallEndT: args.wallEndT,
+    ...scenario.run.offline ? { policy: deepClonePreservingPrototype(scenario.run.offline) } : {}
+  });
+  if (!prepared || typeof prepared !== "object" || Array.isArray(prepared) || "then" in prepared) {
+    throw new RangeError("prepareOffline must synchronously return a preparation object");
+  }
+  if (prepared.stepSec !== undefined && (typeof prepared.stepSec !== "number" || !Number.isFinite(prepared.stepSec) || prepared.stepSec <= 0)) {
+    throw new RangeError("prepareOffline stepSec must be finite and positive");
+  }
+  if (prepared.policy !== undefined)
+    validateCreditPolicy(prepared.policy);
+  const model = prepared.model === undefined ? scenario.model : prepared.model;
+  if (!model || typeof model !== "object" || typeof model.income !== "function" || typeof model.actions !== "function") {
+    throw new RangeError("prepareOffline model must provide income and actions");
+  }
+  return {
+    model,
+    stepSec: prepared.stepSec ?? scenario.run.stepSec,
+    policy: prepared.policy === undefined ? scenario.run.offline : {
+      ...deepClonePreservingPrototype(prepared.policy),
+      actions: scenario.run.offline?.actions
+    }
+  };
+}
+var init_sessionOffline = () => {};
+
 // ../core/dist/sim/session.js
 function buildBlocks(pattern) {
   const blocks = [];
@@ -11700,6 +11757,9 @@ function withClocks(scenario, wallT, wallEndT, rewardT, activeT) {
   };
 }
 function simulateSessionPattern(args) {
+  if (args.prepareOffline !== undefined && typeof args.prepareOffline !== "function") {
+    throw new TypeError("prepareOffline must be a function");
+  }
   const sc = args.seed === undefined ? args.scenario : { ...args.scenario, ctx: { ...args.scenario.ctx, seed: args.seed } };
   const start = sc.initial;
   const horizonSec = args.pattern.days * 86400;
@@ -11786,7 +11846,19 @@ function simulateSessionPattern(args) {
       return;
     const requested = wallEnd - wallT;
     const wallStart = wallT;
-    const segment = segmentScenario(wallStart, wallEnd);
+    let segment = segmentScenario(wallStart, wallEnd);
+    const prepared = prepareOfflineSegment({
+      scenario: segment,
+      state,
+      seconds: requested,
+      wallStartT: wallStart,
+      wallEndT: wallEnd,
+      prepare: args.prepareOffline
+    });
+    if (prepared.model !== segment.model) {
+      const { clocks: _clocks, ...ctx } = segment.ctx;
+      segment = withClocks({ ...segment, ctx, model: prepared.model }, wallStart, wallEnd, state.t, activeSec);
+    }
     const offlineRun = applyOfflineSeconds({
       scenario: segment,
       seconds: requested,
@@ -11798,15 +11870,16 @@ function simulateSessionPattern(args) {
           enabled: sc.run.eventLog?.enabled ?? true,
           maxEvents: sc.run.eventLog?.maxEvents
         },
-        policy: sc.run.offline,
+        stepSec: prepared.stepSec,
+        policy: prepared.policy,
         ...stopFn ? { until: stopFn } : {}
       }
     });
     const credited = offlineRun.offline.simulatedSec;
     const reason = classify();
-    const absence = reason ? offlineAbsenceForCredit(credited, requested, sc.run.offline) : requested;
+    const absence = reason ? offlineAbsenceForCredit(credited, requested, prepared.policy) : requested;
     const gapEnd = wallStart + absence;
-    const effective = absence === requested ? offlineRun.offline.effectiveSec : resolveOfflineSeconds(absence, sc.run.offline).effectiveSec;
+    const effective = absence === requested ? offlineRun.offline.effectiveSec : resolveOfflineSeconds(absence, prepared.policy).effectiveSec;
     const lost = Math.max(0, absence - effective);
     offlineElapsedSec += absence;
     offlineCreditedSec += credited;
@@ -11977,6 +12050,7 @@ var init_session = __esm(() => {
   init_goalRead();
   init_observation();
   init_offline();
+  init_sessionOffline();
   init_simulator();
 });
 
@@ -12972,11 +13046,19 @@ var init_params2 = __esm(() => {
   }));
 });
 
-// ../core/dist/sim/strategy/opt/objectives/builtins.js
-function safeAbsLog10(E, x) {
-  const v = E.absLog10(x);
-  return Number.isFinite(v) ? v : -300;
+// ../core/dist/sim/strategy/opt/finiteAmountLog10.js
+function finiteAmountLog10(E, amount) {
+  if (!E.isFinite(amount))
+    throw new RangeError("Tuning requires finite monetary amounts in the selected engine");
+  const value = E.absLog10(amount);
+  if (value === Number.NEGATIVE_INFINITY)
+    return -300;
+  if (!Number.isFinite(value))
+    throw new RangeError("Tuning requires a finite monetary logarithm");
+  return value;
 }
+
+// ../core/dist/sim/strategy/opt/objectives/builtins.js
 var builtinObjectiveFactories;
 var init_builtins2 = __esm(() => {
   init_parseMoney2();
@@ -12990,7 +13072,7 @@ var init_builtins2 = __esm(() => {
         id: "endMoneyLog10",
         score: ({ scenario, run }) => {
           const { E } = scenario.ctx;
-          return safeAbsLog10(E, run.end.wallet.money.amount);
+          return finiteAmountLog10(E, run.end.wallet.money.amount);
         }
       })
     },
@@ -13003,7 +13085,7 @@ var init_builtins2 = __esm(() => {
         score: ({ scenario, run }) => {
           const { E } = scenario.ctx;
           const worth = scenario.model.netWorth?.(scenario.ctx, run.end) ?? run.end.wallet.money;
-          return safeAbsLog10(E, worth.amount);
+          return finiteAmountLog10(E, worth.amount);
         }
       })
     },
@@ -13018,7 +13100,7 @@ var init_builtins2 = __esm(() => {
           const sec = Math.max(1, runElapsedSec(run));
           const hours = sec / 3600;
           const worth = scenario.model.netWorth?.(scenario.ctx, run.end) ?? run.end.wallet.money;
-          return safeAbsLog10(E, worth.amount) - Math.log10(Math.max(0.000000000001, hours));
+          return finiteAmountLog10(E, worth.amount) - Math.log10(Math.max(0.000000000001, hours));
         }
       })
     },
@@ -13032,7 +13114,7 @@ var init_builtins2 = __esm(() => {
           const { E } = scenario.ctx;
           const sec = Math.max(1, runElapsedSec(run));
           const hours = sec / 3600;
-          return safeAbsLog10(E, run.end.prestige.points) - Math.log10(Math.max(0.000000000001, hours));
+          return finiteAmountLog10(E, run.end.prestige.points) - Math.log10(Math.max(0.000000000001, hours));
         }
       })
     },
@@ -13047,7 +13129,7 @@ var init_builtins2 = __esm(() => {
           const sec = Math.max(1, runElapsedSec(run));
           const startWorth = scenario.model.netWorth?.(scenario.ctx, run.start) ?? run.start.wallet.money;
           const endWorth = scenario.model.netWorth?.(scenario.ctx, run.end) ?? run.end.wallet.money;
-          const deltaLog = safeAbsLog10(E, endWorth.amount) - safeAbsLog10(E, startWorth.amount);
+          const deltaLog = finiteAmountLog10(E, endWorth.amount) - finiteAmountLog10(E, startWorth.amount);
           return deltaLog / (sec / 3600);
         }
       })
@@ -13073,6 +13155,9 @@ var init_builtins2 = __esm(() => {
               suffix: { kind: "alphaInfinite", minLen: 2 }
             }).amount;
             const endWorth = scenario.model.netWorth?.(scenario.ctx, run.end) ?? run.end.wallet.money;
+            if (!E.isFinite(threshold) || !E.isFinite(endWorth.amount)) {
+              throw new RangeError("ETA objective requires finite target and net worth in the selected engine");
+            }
             const reached = E.cmp(endWorth.amount, threshold) >= 0;
             if (!reached)
               return -(params.unreachedPenaltySec ?? 1e9);
@@ -13102,7 +13187,7 @@ var init_builtins2 = __esm(() => {
             const sec = Math.max(1, runElapsedSec(run));
             const hours = sec / 3600;
             const worth = scenario.model.netWorth?.(scenario.ctx, run.end) ?? run.end.wallet.money;
-            const worthLog = safeAbsLog10(E, worth.amount);
+            const worthLog = finiteAmountLog10(E, worth.amount);
             const stats = run.stats;
             if (!stats || stats.money.droppedRate === null || stats.actions.status === "missing") {
               throw new Error("pacingBalancedLog10 needs observed money and action counters, but this run has none (run.observation.enabled is false)");
@@ -13301,8 +13386,45 @@ function cloneCandidateInitial(state) {
 }
 var init_freshRun = () => {};
 
+// ../core/dist/sim/strategy/opt/finiteMean.js
+function finiteMean(values) {
+  if (values.length === 0)
+    throw new RangeError("A mean requires at least one value");
+  const bits = new DataView(new ArrayBuffer(8));
+  let total = 0n;
+  for (const value of values) {
+    if (!Number.isFinite(value))
+      throw new RangeError("A mean requires finite values");
+    bits.setFloat64(0, value, false);
+    const high = bits.getUint32(0, false);
+    const low = bits.getUint32(4, false);
+    const exponent = high >>> 20 & 2047;
+    const fraction = BigInt(high & 1048575) << 32n | BigInt(low);
+    const significand = exponent === 0 ? fraction : 1n << 52n | fraction;
+    const units = significand << BigInt(Math.max(0, exponent - 1));
+    total += high >>> 31 ? -units : units;
+  }
+  if (total === 0n)
+    return 0;
+  const negative = total < 0n;
+  const magnitude = negative ? -total : total;
+  const count = BigInt(values.length);
+  const integerMean = magnitude / count;
+  const shift = Math.max(0, integerMean.toString(2).length - 53);
+  const denominator = count << BigInt(shift);
+  let significand = magnitude / denominator;
+  const twiceRemainder = 2n * (magnitude % denominator);
+  if (twiceRemainder > denominator || twiceRemainder === denominator && (significand & 1n) !== 0n) {
+    significand++;
+  }
+  const mean = Number(significand) * 2 ** (shift - 1074);
+  return negative ? -mean : mean;
+}
+
 // ../core/dist/sim/strategy/opt/runner.js
 function runCandidateAndScore(args) {
+  if (args.seeds.length === 0)
+    throw new RangeError("Tuning requires at least one seed");
   const stratFactory = args.strategyRegistry.get(args.strategyId);
   if (!stratFactory)
     throw new Error(`Unknown strategy: ${args.strategyId}`);
@@ -13349,24 +13471,28 @@ function runCandidateAndScore(args) {
     const sc = openScenario();
     const run = runScenario(sc);
     assertHorizonReached(run, "runCandidateAndScore");
+    const worth = sc.model.netWorth?.(sc.ctx, run.end) ?? run.end.wallet.money;
+    const endMoneyLog10 = finiteAmountLog10(sc.ctx.E, run.end.wallet.money.amount);
+    const endNetWorthLog10 = finiteAmountLog10(sc.ctx.E, worth.amount);
     const s = objective.score({ scenario: sc, run, evaluation: {
       open: openScenario,
       registries: { models: args.modelRegistry, strategies: args.strategyRegistry },
       isolation: { model: args.model, statefulModel: args.statefulModel, strategy: { id: args.strategyId, params: candidateParams } }
     } });
+    if (!Number.isFinite(s))
+      throw new RangeError(`Objective ${args.objectiveId} must return a finite score (seed ${seed})`);
     seedScores.push(s);
-    const worth = sc.model.netWorth?.(sc.ctx, run.end) ?? run.end.wallet.money;
     seedResults.push({
       seed,
       score: s,
       durationSec: Math.max(0, runElapsedSec(run)),
-      endMoneyLog10: sc.ctx.E.absLog10(run.end.wallet.money.amount),
-      endNetWorthLog10: sc.ctx.E.absLog10(worth.amount),
+      endMoneyLog10,
+      endNetWorthLog10,
       droppedRate: run.stats?.money.droppedRate ?? null,
       actionsApplied: run.stats && run.stats.actions.status === "observed" ? run.stats.actions.applied : null
     });
   }
-  const score = seedScores.reduce((a, b) => a + b, 0) / Math.max(1, seedScores.length);
+  const score = finiteMean(seedScores);
   return { score, seedScores, seedResults };
 }
 var init_runner = __esm(() => {
@@ -14353,7 +14479,7 @@ function compensatedSum(values, scale) {
   }
   return sum + compensation;
 }
-function finiteMean(values) {
+function finiteMean2(values) {
   let smallest = Number.POSITIVE_INFINITY;
   let largest = Number.NEGATIVE_INFINITY;
   for (const value of values) {
@@ -14503,7 +14629,7 @@ function analyzeDistribution(request) {
   }
   const eligible = observed.length + rightCensored;
   const completionRate = eligible > 0 ? observed.length / eligible : null;
-  const arithmetic = observed.length > 0 ? finiteMean(observed) : null;
+  const arithmetic = observed.length > 0 ? finiteMean2(observed) : null;
   const identical = observed.every((value) => value === observed[0]);
   const rawVariance = arithmetic === null ? null : finiteVariance(observed, arithmetic);
   const variance = rawVariance === 0 && !identical ? null : rawVariance;
@@ -19353,32 +19479,46 @@ function buildTimeline(args) {
 }
 
 // ../core/dist/report/compare.js
-function safeNum(input) {
-  if (typeof input === "number")
-    return input;
-  if (typeof input === "string") {
-    const n = Number(input);
-    if (Number.isFinite(n))
-      return n;
-    const m = /^\s*([+-]?\d+(?:\.\d+)?)e([+-]?\d+)\s*$/i.exec(input);
-    if (m) {
-      const mantissa = Number(m[1]);
-      const exp = Number(m[2]);
-      if (mantissa === 0)
-        return 0;
-      if (Number.isFinite(mantissa) && Number.isFinite(exp)) {
-        return Math.log10(Math.abs(mantissa)) + exp;
-      }
-    }
-  }
-  return Number.NaN;
+function decimalParts(input) {
+  const match = /^([+-]?)(?:(\d+)(?:\.(\d+))?|\.(\d+))(?:e([+-]?\d+))?([a-z]{2,})?$/i.exec(input.trim());
+  if (!match)
+    throw new RangeError("Static monetary comparison requires decimal amounts");
+  let suffixExponent = 0n;
+  if (match[6]) {
+    let index = 0n;
+    for (const ch of match[6].toLowerCase())
+      index = index * 26n + BigInt(ch.charCodeAt(0) - 96);
+    suffixExponent = (index - 26n) * 3n;
+  }
+  const fraction = match[3] ?? match[4] ?? "";
+  const digits = `${match[2] ?? ""}${fraction}`.replace(/^0+/, "");
+  let end = digits.length;
+  while (end > 0 && digits[end - 1] === "0")
+    end--;
+  return {
+    sign: digits.length === 0 ? 0 : match[1] === "-" ? -1 : 1,
+    digits: digits.slice(0, end),
+    magnitude: BigInt(match[5] ?? "0") + suffixExponent - BigInt(fraction.length) + BigInt(digits.length)
+  };
+}
+function compareStaticMoney(left, right) {
+  const a = decimalParts(left), b = decimalParts(right);
+  if (a.sign !== b.sign)
+    return a.sign < b.sign ? -1 : 1;
+  if (a.sign === 0)
+    return 0;
+  if (a.magnitude !== b.magnitude)
+    return (a.magnitude < b.magnitude ? -1 : 1) * a.sign;
+  const length = Math.max(a.digits.length, b.digits.length);
+  const ad = a.digits.padEnd(length, "0"), bd = b.digits.padEnd(length, "0");
+  return (ad < bd ? -1 : ad > bd ? 1 : 0) * a.sign;
 }
 function score(s, metric) {
   switch (metric) {
     case "endMoney":
-      return safeNum(s.initial.wallet.amount);
+      return s.initial.wallet.amount;
     case "endNetWorth":
-      return safeNum(s.initial.maxMoneyEver ?? s.initial.wallet.amount);
+      return s.initial.maxMoneyEver ?? s.initial.wallet.amount;
     case "droppedRate":
       return -(s.policy.maxLogGap ?? 0);
     case "etaToTargetWorth":
@@ -19417,6 +19557,13 @@ function compareScenarios(args) {
   const useMeasured = measuredA !== undefined && measuredB !== undefined;
   const aScore = useMeasured ? measuredA : score(args.a, args.metric);
   const bScore = useMeasured ? measuredB : score(args.b, args.metric);
+  if (!useMeasured && (args.metric === "endMoney" || args.metric === "endNetWorth")) {
+    const order = compareStaticMoney(String(aScore), String(bScore));
+    return {
+      better: order === 0 ? "tie" : order > 0 ? "a" : "b",
+      detail: { aScore, bScore, metric: args.metric, source: "static" }
+    };
+  }
   const higherBetter = args.metric === "endMoney" || args.metric === "endNetWorth" || args.metric === "visibleChangesPerMinute";
   if (aScore === bScore) {
     return {
@@ -19797,6 +19944,151 @@ var init_public = __esm(() => {
   init_uncertainty();
 });
 
+// ../core/dist/ltv/cohort.js
+function wilsonInterval(activeUsers, users) {
+  const rate = activeUsers / users;
+  const z2 = 1.959963984540054 ** 2;
+  const denominator = 1 + z2 / users;
+  const center = (rate + z2 / (2 * users)) / denominator;
+  const radius = Math.sqrt(z2 * (rate * (1 - rate) / users + z2 / (4 * users * users))) / denominator;
+  return { min: activeUsers === 0 ? 0 : Math.max(0, center - radius), max: activeUsers === users ? 1 : Math.min(1, center + radius) };
+}
+function observeCohort(rows, observedThroughDay) {
+  if (!Number.isSafeInteger(observedThroughDay) || observedThroughDay < 0)
+    throw new Error("observed-through-day must be a nonnegative safe integer");
+  if (!Array.isArray(rows) || rows.length === 0)
+    throw new Error("Observed cohort requires at least one install record");
+  const users = new Map;
+  for (const row of rows) {
+    if (!row || typeof row.userId !== "string" || !row.userId.trim() || !Number.isSafeInteger(row.day) || row.day < 0 || row.day > observedThroughDay) {
+      throw new Error("Observed cohort requires a user ID and integer days within observed-through-day");
+    }
+    if (![row.iapRevenue, row.adRevenue, row.acquisitionCost].every((v) => v === undefined || typeof v === "number" && Number.isFinite(v) && v >= 0)) {
+      throw new Error("Observed cohort revenue and acquisition costs must be finite and nonnegative");
+    }
+    if (row.active !== undefined && typeof row.active !== "boolean")
+      throw new Error("Observed cohort active must be boolean");
+    const user = users.get(row.userId) ?? { days: new Set, active: new Set };
+    if (user.days.has(row.day))
+      throw new Error("Observed cohort requires one aggregated row per user and day");
+    user.days.add(row.day);
+    if (row.active ?? true)
+      user.active.add(row.day);
+    users.set(row.userId, user);
+  }
+  for (const user of users.values()) {
+    if (!user.days.has(0))
+      throw new Error("Observed cohort requires a day 0 install record for every user, including inactive users");
+  }
+  const n = users.size;
+  const observation = {
+    observedThroughDay,
+    users: n,
+    retention: RETENTION_DAYS.map((day) => {
+      if (day > observedThroughDay)
+        return { day, status: "not-observed", users: n, activeUsers: null, rate: null, interval95: null };
+      const activeUsers = [...users.values()].filter((user) => user.active.has(day)).length;
+      const rate = activeUsers / n;
+      return { day, status: "observed", users: n, activeUsers, rate, interval95: wilsonInterval(activeUsers, n) };
+    })
+  };
+  assertCohortObservation(observation);
+  return observation;
+}
+function object2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertCohortObservation(observation) {
+  if (!object2(observation) || typeof observation.users !== "number" || !Number.isSafeInteger(observation.users) || observation.users < 1 || typeof observation.observedThroughDay !== "number" || !Number.isSafeInteger(observation.observedThroughDay) || observation.observedThroughDay < 0) {
+    throw new Error("Invalid cohort population or observation cutoff");
+  }
+  if (!Array.isArray(observation.retention) || observation.retention.length !== RETENTION_DAYS.length)
+    throw new Error("Cohort retention must contain D1, D7, D30 and D90");
+  for (const [index, value] of observation.retention.entries()) {
+    const point = value;
+    if (!object2(point) || typeof point.day !== "number" || point.day !== RETENTION_DAYS[index] || point.users !== observation.users)
+      throw new Error("Cohort retention days and population must match the observation");
+    const observed = point.day <= observation.observedThroughDay;
+    if (point.status !== (observed ? "observed" : "not-observed"))
+      throw new Error("Cohort retention status must match the observation cutoff");
+    if (!observed) {
+      if (point.activeUsers !== null || point.rate !== null || point.interval95 !== null)
+        throw new Error("Future retention must remain unobserved");
+      continue;
+    }
+    if (typeof point.activeUsers !== "number" || !Number.isSafeInteger(point.activeUsers) || point.activeUsers < 0 || point.activeUsers > observation.users || point.rate !== point.activeUsers / observation.users) {
+      throw new Error("Retained users and retention rate must match the installed population");
+    }
+    const interval = point.interval95;
+    if (typeof point.rate !== "number" || !object2(interval) || typeof interval.min !== "number" || typeof interval.max !== "number" || !Number.isFinite(interval.min) || !Number.isFinite(interval.max) || interval.min < 0 || interval.max > 1 || interval.min > point.rate || interval.max < point.rate) {
+      throw new Error("Retention confidence interval must be finite and contain the observed rate");
+    }
+    const expected = wilsonInterval(point.activeUsers, observation.users);
+    if (interval.min !== expected.min || interval.max !== expected.max) {
+      throw new Error("Retention confidence interval must match the Wilson 95% bounds for the observed population");
+    }
+  }
+}
+function observedRetentionRates(observation) {
+  assertCohortObservation(observation);
+  const rates = {};
+  for (const row of observation.retention) {
+    if (row.rate !== null)
+      rates[`d${row.day}`] = row.rate;
+  }
+  return rates;
+}
+function assertRetentionAssumptions(assumptions) {
+  if (!object2(assumptions))
+    throw new RangeError("Retention assumptions must be an object");
+  for (const day of RETENTION_DAYS) {
+    const rate = assumptions[`d${day}`];
+    if (rate !== undefined && (typeof rate !== "number" || !Number.isFinite(rate) || rate < 0 || rate > 1)) {
+      throw new RangeError(`Retention assumption d${day} must be finite and in 0..1`);
+    }
+  }
+}
+function planRetentionPatch(observation, assumptions = {}) {
+  assertRetentionAssumptions(assumptions);
+  const rates = observedRetentionRates(observation);
+  if (Object.keys(rates).length === 0)
+    return { status: "unavailable", retention: {}, warnings: ["No retention day has been fully observed."] };
+  const merged = { ...assumptions, ...rates };
+  const warnings = [];
+  for (const day of RETENTION_DAYS) {
+    if (merged[`d${day}`] === undefined)
+      warnings.push(`Unobserved D${day} has no explicit retained assumption. An LTV default could conflict with the observations; supply monetization.retention.d${day} in the scenario or observe this day before applying a patch.`);
+  }
+  let previous;
+  for (const day of RETENTION_DAYS) {
+    const rate = merged[`d${day}`];
+    if (rate === undefined)
+      continue;
+    if (previous && previous.rate < rate)
+      warnings.push(`D${previous.day}=${previous.rate} is below D${day}=${rate}. LTV requires d1 >= d7 >= d30 >= d90; review observations and retained assumptions before applying a patch.`);
+    previous = { day, rate };
+  }
+  return warnings.length ? { status: "requires-review", retention: {}, warnings } : { status: "ready", retention: rates, warnings };
+}
+function compareRetention(observation, assumptions) {
+  assertCohortObservation(observation);
+  assertRetentionAssumptions(assumptions);
+  return observation.retention.map((row) => {
+    const assumption = assumptions[`d${row.day}`] ?? null;
+    return {
+      day: row.day,
+      assumption,
+      observed: row.rate,
+      differencePercentagePoints: row.rate === null || assumption === null ? null : (row.rate - assumption) * 100,
+      status: row.rate === null ? "not-observed" : assumption === null ? "unconfigured" : "compared"
+    };
+  });
+}
+var RETENTION_DAYS;
+var init_cohort = __esm(() => {
+  RETENTION_DAYS = Object.freeze([1, 7, 30, 90]);
+});
+
 // ../core/dist/index.js
 var init_dist2 = __esm(() => {
   init_types();
@@ -19863,6 +20155,7 @@ var init_dist2 = __esm(() => {
   init_flow();
   init_jevAdvisory();
   init_public();
+  init_cohort();
 });
 
 // src/runtime/bun.ts
@@ -19928,7 +20221,7 @@ var init_bun = __esm(() => {
 var require_package = __commonJS(function(exports, module) {
   module.exports = {
     name: "@idlekit/cli",
-    version: "0.5.1",
+    version: "0.6.0",
     description: "Bun-first idk CLI for idle game scenario validation, simulation, tuning, and reporting.",
     license: "MIT",
     type: "module",
@@ -19981,7 +20274,7 @@ var require_package = __commonJS(function(exports, module) {
       "@clack/prompts": "1.8.1",
       "@gunshi/plugin-completion": "0.37.3",
       "@gunshi/plugin-suggestion": "0.37.3",
-      "@idlekit/core": "0.5.0",
+      "@idlekit/core": "0.6.0",
       ajv: "^8.20.0",
       gunshi: "0.37.3",
       "proper-lockfile": "4.1.2",
@@ -34920,8 +35213,8 @@ function ownedCount(state) {
 }
 function finiteLinearAmount(E, value, label) {
   if (!E.isFinite(value)) {
-    throw cliError("SCENARIO_INVALID", `linear ${label} exceeds the selected engine's finite range. Use --engine breakInfinity with simulate/evaluate/experience/ltv for a large economy, or reduce the inputs.`, {
-      hint: "Other commands, including report/compare/tune, use the number engine; reduce their inputs."
+    throw cliError("SCENARIO_INVALID", `linear ${label} exceeds the selected engine's finite range. Use --engine breakInfinity with simulate/evaluate/experience/ltv/compare/tune/balance for a large economy, or reduce the inputs.`, {
+      hint: "The report command uses the number engine; reduce its inputs."
     });
   }
   return value;
@@ -37108,115 +37401,7 @@ init_dist2();
 // src/lib/ltvUncertainty.ts
 init_dist2();
 // src/lib/cohortObservation.ts
-var RETENTION_DAYS = [1, 7, 30, 90];
-function observeCohort(rows, observedThroughDay) {
-  if (!Number.isSafeInteger(observedThroughDay) || observedThroughDay < 0)
-    throw new Error("observed-through-day must be a nonnegative safe integer");
-  if (rows.length === 0)
-    throw new Error("Observed cohort requires at least one install record");
-  const users = new Map;
-  for (const row of rows) {
-    if (!row.userId.trim() || !Number.isSafeInteger(row.day) || row.day < 0 || row.day > observedThroughDay) {
-      throw new Error("Observed cohort requires a user ID and integer days within observed-through-day");
-    }
-    if (![row.iapRevenue, row.adRevenue, ...row.acquisitionCost === undefined ? [] : [row.acquisitionCost]].every((v) => Number.isFinite(v) && v >= 0)) {
-      throw new Error("Observed cohort revenue and acquisition costs must be finite and nonnegative");
-    }
-    if (row.active !== undefined && typeof row.active !== "boolean")
-      throw new Error("Observed cohort active must be boolean");
-    const user = users.get(row.userId) ?? { days: new Set, active: new Set };
-    if (user.days.has(row.day))
-      throw new Error("Observed cohort requires one aggregated row per user and day");
-    user.days.add(row.day);
-    if (row.active ?? true)
-      user.active.add(row.day);
-    users.set(row.userId, user);
-  }
-  for (const user of users.values()) {
-    if (!user.days.has(0))
-      throw new Error("Observed cohort requires a day 0 install record for every user, including inactive users");
-  }
-  const n = users.size;
-  const observation = {
-    observedThroughDay,
-    users: n,
-    retention: RETENTION_DAYS.map((day) => {
-      if (day > observedThroughDay)
-        return { day, status: "not-observed", users: n, activeUsers: null, rate: null, interval95: null };
-      const activeUsers = [...users.values()].filter((user) => user.active.has(day)).length;
-      const rate = activeUsers / n;
-      const z2 = 1.959963984540054 ** 2;
-      const denominator = 1 + z2 / n;
-      const center = (rate + z2 / (2 * n)) / denominator;
-      const radius = Math.sqrt(z2 * (rate * (1 - rate) / n + z2 / (4 * n * n))) / denominator;
-      return { day, status: "observed", users: n, activeUsers, rate, interval95: { min: activeUsers === 0 ? 0 : Math.max(0, center - radius), max: activeUsers === n ? 1 : Math.min(1, center + radius) } };
-    })
-  };
-  assertCohortObservation(observation);
-  return observation;
-}
-function assertCohortObservation(observation) {
-  if (!Number.isSafeInteger(observation.users) || observation.users < 1 || !Number.isSafeInteger(observation.observedThroughDay) || observation.observedThroughDay < 0) {
-    throw new Error("Invalid cohort population or observation cutoff");
-  }
-  if (observation.retention.length !== RETENTION_DAYS.length)
-    throw new Error("Cohort retention must contain D1, D7, D30 and D90");
-  for (const [index, point] of observation.retention.entries()) {
-    if (point.day !== RETENTION_DAYS[index] || point.users !== observation.users)
-      throw new Error("Cohort retention days and population must match the observation");
-    const observed = point.day <= observation.observedThroughDay;
-    if (point.status !== (observed ? "observed" : "not-observed"))
-      throw new Error("Cohort retention status must match the observation cutoff");
-    if (!observed) {
-      if (point.activeUsers !== null || point.rate !== null || point.interval95 !== null)
-        throw new Error("Future retention must remain unobserved");
-      continue;
-    }
-    if (point.activeUsers === null || !Number.isSafeInteger(point.activeUsers) || point.activeUsers < 0 || point.activeUsers > point.users || point.rate !== point.activeUsers / point.users) {
-      throw new Error("Retained users and retention rate must match the installed population");
-    }
-    const interval = point.interval95;
-    if (point.rate === null || !interval || !Number.isFinite(interval.min) || !Number.isFinite(interval.max) || interval.min < 0 || interval.max > 1 || interval.min > point.rate || interval.max < point.rate) {
-      throw new Error("Retention confidence interval must be finite and contain the observed rate");
-    }
-  }
-}
-function observedRetentionRates(observation) {
-  return Object.fromEntries(observation.retention.filter((row) => row.rate !== null).map((row) => [`d${row.day}`, row.rate]));
-}
-function planRetentionPatch(observation, assumptions = {}) {
-  const rates = observedRetentionRates(observation);
-  if (Object.keys(rates).length === 0)
-    return { status: "unavailable", retention: {}, warnings: ["No retention day has been fully observed."] };
-  const merged = { ...assumptions, ...rates };
-  const warnings = [];
-  for (const day of RETENTION_DAYS) {
-    if (merged[`d${day}`] === undefined)
-      warnings.push(`Unobserved D${day} has no explicit retained assumption. An LTV default could conflict with the observations; supply this assumption in --scenario or observe this day before applying a patch.`);
-  }
-  let previous;
-  for (const day of RETENTION_DAYS) {
-    const rate = merged[`d${day}`];
-    if (rate === undefined)
-      continue;
-    if (previous && previous.rate < rate)
-      warnings.push(`D${previous.day}=${previous.rate} is below D${day}=${rate}. LTV requires d1 >= d7 >= d30 >= d90; review observations and retained assumptions before applying a patch.`);
-    previous = { day, rate };
-  }
-  return warnings.length ? { status: "requires-review", retention: {}, warnings } : { status: "ready", retention: rates, warnings };
-}
-function compareRetention(observation, assumptions) {
-  return observation.retention.map((row) => {
-    const assumption = assumptions[`d${row.day}`] ?? null;
-    return {
-      day: row.day,
-      assumption,
-      observed: row.rate,
-      differencePercentagePoints: row.rate === null || assumption === null ? null : (row.rate - assumption) * 100,
-      status: row.rate === null ? "not-observed" : assumption === null ? "unconfigured" : "compared"
-    };
-  });
-}
+init_dist2();
 function renderCohortMarkdown(observation, comparison, patch) {
   const percent = (value) => value === null ? "unavailable" : `${(value * 100).toFixed(2)}%`;
   const lines = [
@@ -37541,6 +37726,42 @@ var CLI_DESCRIPTION = import_package2.default.description ?? "Bun-first idle gam
 // src/balance/workflow.ts
 init_bun();
 
+// src/balance/pacingAmount.ts
+var MAX_DECIMAL_LENGTH = 200;
+var DECIMAL = /^([+-]?)(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([+-]?\d+))?$/;
+function pacingValue(value) {
+  if (typeof value === "number")
+    return Number.isFinite(value) ? Object.is(value, -0) ? 0 : value : undefined;
+  return typeof value === "string" && value.length <= MAX_DECIMAL_LENGTH && DECIMAL.test(value) ? value : undefined;
+}
+function parts(value) {
+  if (pacingValue(value) === undefined)
+    throw new RangeError("Pacing value must be finite or bounded decimal text");
+  const match = DECIMAL.exec(String(value));
+  const fraction = match[3] ?? match[4] ?? "";
+  const digits = `${match[2] ?? ""}${fraction}`.replace(/^0+/, "");
+  const sign = digits.length === 0 ? 0 : match[1] === "-" ? -1 : 1;
+  return {
+    sign,
+    digits: digits.replace(/0+$/, ""),
+    magnitude: BigInt(match[5] ?? "0") - BigInt(fraction.length) + BigInt(digits.length)
+  };
+}
+function comparePacingValues(left, right) {
+  if (typeof left === "number" && typeof right === "number")
+    return left < right ? -1 : left > right ? 1 : 0;
+  const a = parts(left), b = parts(right);
+  if (a.sign !== b.sign)
+    return a.sign < b.sign ? -1 : 1;
+  if (a.sign === 0)
+    return 0;
+  if (a.magnitude !== b.magnitude)
+    return (a.magnitude < b.magnitude ? -1 : 1) * a.sign;
+  const length = Math.max(a.digits.length, b.digits.length);
+  const ad = a.digits.padEnd(length, "0"), bd = b.digits.padEnd(length, "0");
+  return (ad < bd ? -1 : ad > bd ? 1 : 0) * a.sign;
+}
+
 // src/balance/pacing.ts
 var PACING_LIMITS = Object.freeze({
   maxRuns: 1000,
@@ -37582,6 +37803,12 @@ function finite2(value, label) {
     invalid(`${label} must be finite`);
   return Object.is(value, -0) ? 0 : value;
 }
+function bound(value, label) {
+  const parsed = pacingValue(value);
+  if (parsed === undefined)
+    invalid(`${label} must be finite or decimal text of at most 200 characters`);
+  return parsed;
+}
 function limit(value, maximum, label) {
   if (value === undefined)
     return maximum;
@@ -37640,11 +37867,11 @@ function planPacingRuns(input) {
     if (metrics.has(metric))
       invalid(`duplicate target metric ${metric}`);
     metrics.add(metric);
-    const min = raw.min === undefined ? undefined : finite2(raw.min, `targets[${index}].min`);
-    const max = raw.max === undefined ? undefined : finite2(raw.max, `targets[${index}].max`);
+    const min = raw.min === undefined ? undefined : bound(raw.min, `targets[${index}].min`);
+    const max = raw.max === undefined ? undefined : bound(raw.max, `targets[${index}].max`);
     if (min === undefined && max === undefined)
       invalid(`target ${metric} needs min or max`);
-    if (min !== undefined && max !== undefined && min > max)
+    if (min !== undefined && max !== undefined && comparePacingValues(min, max) > 0)
       invalid(`target ${metric} min exceeds max`);
     return Object.freeze({ metric, unit, ...min !== undefined ? { min } : {}, ...max !== undefined ? { max } : {} });
   }).sort((left, right) => compareText(left.metric, right.metric));
@@ -37723,11 +37950,12 @@ function checkTarget(target, metrics) {
   const value = metrics[target.metric];
   if (value === null)
     return { ...target, value, status: "unreached", message: "Metric not reached within the run horizon" };
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return { ...target, value: null, status: "error", message: "Evaluator metric must be a finite number or null" };
+  const parsed = pacingValue(value);
+  if (parsed === undefined) {
+    return { ...target, value: null, status: "error", message: "Evaluator metric must be a finite number, bounded decimal text or null" };
   }
-  const breached = target.min !== undefined && value < target.min || target.max !== undefined && value > target.max;
-  return { ...target, value: Object.is(value, -0) ? 0 : value, status: breached ? "breach" : "pass" };
+  const breached = target.min !== undefined && comparePacingValues(parsed, target.min) < 0 || target.max !== undefined && comparePacingValues(parsed, target.max) > 0;
+  return { ...target, value: parsed, status: breached ? "breach" : "pass" };
 }
 async function runPacingChecks(input, evaluator) {
   const plan = planPacingRuns(input);
@@ -38491,7 +38719,8 @@ async function refreshBalanceWorkflow(configPath, flags, check = false) {
   const loaded = await loadRegistriesFromFlags(flags);
   for (const [index, path] of Object.keys(loaded.pluginDigest).entries())
     inputFiles[`plugin${index}`] = path;
-  const context = { cliVersion: CLI_VERSION, bunVersion: Bun.version, pluginDigests: JSON.stringify(loaded.pluginDigest), engine: "number" };
+  const engine = resolveEffectiveEngine({ requested: flags.engine });
+  const context = { cliVersion: CLI_VERSION, bunVersion: Bun.version, pluginDigests: JSON.stringify(loaded.pluginDigest), engine: engine.effectiveId };
   const outputDir = resolve10(base, config.outputDir);
   if (check)
     return readCurrentBundle(outputDir, inputFiles, { context });
@@ -38528,7 +38757,7 @@ async function refreshBalanceWorkflow(configPath, flags, check = false) {
       const metricIds = new Set(config.metrics.map((metric) => metric.id));
       if (metricIds.size !== config.metrics.length)
         throw new Error("Metric IDs must be unique");
-      const targets = config.pacing.targets ?? [];
+      const targets = plan.targets;
       for (const target of targets)
         if (!metricIds.has(target.metric))
           throw new Error(`Unknown target metric: ${target.metric}`);
@@ -38550,6 +38779,9 @@ async function refreshBalanceWorkflow(configPath, flags, check = false) {
         const unit = metric.kind === "firstAction" || metric.kind === "firstActionPrefix" ? "seconds" : metric.kind === "endWallet" || metric.kind === "endNetWorth" ? baselineDocument.unit.code : "count";
         if (target.unit !== unit)
           throw new Error(`Target ${target.metric} must use unit '${unit}'`);
+        if (metric.kind !== "endWallet" && metric.kind !== "endNetWorth" && (typeof target.min === "string" || typeof target.max === "string")) {
+          throw new Error(`Target ${target.metric} requires finite numeric time or count bounds`);
+        }
       }
       const materialize = (patches) => {
         const candidate = applySheetCsv(template, schema, overlayCsv(canonicalCsv, patches));
@@ -38567,7 +38799,7 @@ async function refreshBalanceWorkflow(configPath, flags, check = false) {
           modelRegistry: loaded.modelRegistry,
           strategyRegistry: loaded.strategyRegistry,
           pluginDigest: loaded.pluginDigest,
-          engineRequest: "number",
+          engineRequest: engine.effectiveId,
           seed: descriptor.seed
         });
         const opened = prepared.open("simulate", `simulate:${descriptor.seed}`, { durationSec: descriptor.horizonSec });
@@ -38589,6 +38821,13 @@ async function refreshBalanceWorkflow(configPath, flags, check = false) {
           throw new Error("Action history exceeded the result budget; pacing cannot be inferred from truncated history");
         const actions = run.actionsLog ?? [];
         const result = {};
+        const monetary = (amount) => {
+          const E = opened.scenario.ctx.E;
+          if (!E.isFinite(amount))
+            throw new Error("Monetary metric overflowed the selected engine");
+          const decimal = E.toString(amount);
+          return engine.effectiveId === "number" ? Number(decimal) : decimal;
+        };
         for (const metric of config.metrics) {
           if (metric.kind === "firstAction" || metric.kind === "firstActionPrefix") {
             const action = actions.find((item) => metric.kind === "firstAction" ? item.actionId === metric.actionId : item.actionId.startsWith(metric.prefix));
@@ -38598,12 +38837,12 @@ async function refreshBalanceWorkflow(configPath, flags, check = false) {
           else if (metric.kind === "actionCount")
             result[metric.id] = actions.length;
           else if (metric.kind === "endWallet")
-            result[metric.id] = Number(run.end.wallet.money.amount);
+            result[metric.id] = monetary(run.end.wallet.money.amount);
           else {
             const worth = opened.scenario.model.netWorth?.(opened.scenario.ctx, run.end);
             if (!worth)
               throw new Error("endNetWorth requires model.netWorth; wallet is not a substitute");
-            result[metric.id] = Number(worth.amount);
+            result[metric.id] = monetary(worth.amount);
           }
         }
         return result;
@@ -38661,7 +38900,7 @@ async function refreshBalanceWorkflow(configPath, flags, check = false) {
 `);
           return { id: variant.id, scenario: name };
         });
-        addArtifact("variants.json", JSON.stringify({ version: 1, engine: "number", seeds: plan.seeds, horizonSec: horizon, strategy: plan.strategy, variants }, null, 2) + `
+        addArtifact("variants.json", JSON.stringify({ version: 1, engine: engine.effectiveId, seeds: plan.seeds, horizonSec: horizon, strategy: plan.strategy, variants }, null, 2) + `
 `);
       }
       return artifacts;
@@ -38676,10 +38915,10 @@ function cell(value) {
 }
 function explain(result) {
   if (result.status === "breach" && result.value !== null) {
-    if (result.min !== undefined && result.value < result.min)
-      return `below the minimum by ${result.min - result.value} ${result.unit}`;
-    if (result.max !== undefined && result.value > result.max)
-      return `above the maximum by ${result.value - result.max} ${result.unit}`;
+    if (result.min !== undefined && comparePacingValues(result.value, result.min) < 0)
+      return typeof result.min === "number" && typeof result.value === "number" ? `below the minimum by ${result.min - result.value} ${result.unit}` : `below the minimum ${result.min} ${result.unit}`;
+    if (result.max !== undefined && comparePacingValues(result.value, result.max) > 0)
+      return typeof result.max === "number" && typeof result.value === "number" ? `above the maximum by ${result.value - result.max} ${result.unit}` : `above the maximum ${result.max} ${result.unit}`;
   }
   if (result.status === "pass")
     return "within the inclusive target bounds";
@@ -38718,6 +38957,7 @@ var balance_default = defineCommand({
   description: "Refresh a typed CSV balance sheet into scenario, pacing checks, and result sheets",
   options: {
     ...pluginOptions(),
+    engine: option(string2().min(1).optional(), { description: "Numeric engine (default: number; explicit: breakInfinity)" }),
     check: option(exports_coerce.boolean().default(false), { description: "Check result freshness without rerunning simulations" }),
     format: option(_enum(["json", "md"]).default("json"), { description: "JSON manifest or human-readable target explanations" })
   },
@@ -39174,6 +39414,7 @@ function compareIdentity2(args) {
   return {
     a: side(args.scenarios.a),
     b: side(args.scenarios.b),
+    ...args.engineId && args.engineId !== "number" ? { engineId: args.engineId } : {},
     pluginDigests: pluginDigestValues(args.loaded.pluginDigest),
     metrics,
     bundle: flags.bundle ?? null,
@@ -39182,9 +39423,16 @@ function compareIdentity2(args) {
   };
 }
 function measureScenario(args) {
+  const requireFinite = (amount, label) => {
+    if (!args.E.isFinite(amount))
+      throw new RangeError(`compare ${label} must be finite in the selected engine`);
+    return amount;
+  };
   const runInput = args.compiled.fresh("economy");
   const run = runScenario(runInput);
   const endWorth = runInput.model.netWorth?.(runInput.ctx, run.end) ?? run.end.wallet.money;
+  requireFinite(run.end.wallet.money.amount, "end money");
+  requireFinite(endWorth.amount, "end net worth");
   let etaSeconds;
   let etaReached;
   if (args.targetWorth) {
@@ -39193,7 +39441,12 @@ function measureScenario(args) {
       unit: etaInput.ctx.unit,
       suffix: { kind: "alphaInfinite", minLen: 2 }
     }).amount;
-    const reachedFn = (s) => args.E.cmp((etaInput.model.netWorth?.(etaInput.ctx, s) ?? s.wallet.money).amount, target) >= 0;
+    requireFinite(target, "ETA target");
+    const reachedFn = (s) => {
+      requireFinite(s.wallet.money.amount, "ETA money");
+      const worth = etaInput.model.netWorth?.(etaInput.ctx, s) ?? s.wallet.money;
+      return args.E.cmp(requireFinite(worth.amount, "ETA net worth"), target) >= 0;
+    };
     const etaRun = runScenario({
       ...etaInput,
       run: {
@@ -39475,6 +39728,7 @@ var compare_default = defineCommand({
   description: "Compare two scenarios via measured simulation metrics",
   options: {
     ...pluginOptions(),
+    engine: option(string2().min(1).optional(), { description: "Numeric engine (default: number; explicit: breakInfinity)" }),
     duration: option(exports_coerce.number().optional(), { description: "Override durationSec" }),
     step: option(exports_coerce.number().optional(), { description: "Override stepSec" }),
     strategy: option(strategySchema, { description: "Override strategy id (greedy|planner|scripted)" }),
@@ -39530,7 +39784,8 @@ var compare_default = defineCommand({
       throw usageError("metric=timeToMilestone requires --milestone-key <key>");
     }
     const scenarios = { a: aScenario, b: bScenario };
-    const identity = compareIdentity2({ scenarios, flags, loaded });
+    const engine = resolveEffectiveEngine({ requested: flags.engine });
+    const identity = compareIdentity2({ scenarios, flags, loaded, engineId: engine.effectiveId });
     const effectiveSeed = flags.seed ?? defaultRunSeed({
       base: {
         command: "compare",
@@ -39550,9 +39805,12 @@ var compare_default = defineCommand({
           milestoneKey: undefined
         }
       },
-      runs: [{ identity, defaults: compareIdentity2({ scenarios, flags: { "max-duration": DEFAULT_MAX_DURATION }, loaded }) }]
+      runs: [{ identity, defaults: {
+        ...compareIdentity2({ scenarios, flags: { "max-duration": DEFAULT_MAX_DURATION }, loaded }),
+        engineId: "number"
+      } }]
     });
-    const E = createNumberEngine();
+    const E = engine.engine;
     const aCompiled = compileComparableScenario({
       scenario: aScenario,
       E,
@@ -42190,6 +42448,7 @@ var tune_default = defineCommand({
   description: "Tune strategy parameters with objective scoring",
   options: {
     ...pluginOptions(),
+    engine: option(string2().min(1).optional(), { description: "Numeric engine (default: number; explicit: breakInfinity)" }),
     tune: option(string2().optional(), { description: "TuneSpec file path (.json|.yaml)" }),
     wizard: option(exports_coerce.boolean().default(false), {
       description: "Interactively generate a TuneSpec before tuning"
@@ -42245,11 +42504,14 @@ var tune_default = defineCommand({
     const tuneSpecInput = wizardResult?.tuneSpec ?? await readScenarioFile(tunePath);
     const baselinePath = flags["baseline-artifact"] ? resolve21(flags["baseline-artifact"]) : undefined;
     const baselineRaw = baselinePath ? await readJsonFile(baselinePath) : undefined;
+    const engine = resolveEffectiveEngine({ requested: flags.engine });
+    const engineIdentity = engine.effectiveId === "number" ? {} : { engineId: engine.effectiveId };
     const seed = flags.seed ?? deriveDeterministicSeed({
       command: "tune",
       scenario: scenarioInput,
       tuneSpec: tuneSpecInput,
       options: {
+        ...engineIdentity,
         baselineArtifact: baselineRaw === undefined ? undefined : hashContent(baselineRaw),
         regressionTolerance: flags["regression-tolerance"]
       }
@@ -42257,7 +42519,7 @@ var tune_default = defineCommand({
     const runId = flags["run-id"] ?? deriveDeterministicRunId({
       command: "tune",
       seed,
-      scope: { scenario: scenarioInput, tuneSpec: tuneSpecInput, pluginDigests: Object.values(loaded.pluginDigest) }
+      scope: { scenario: scenarioInput, tuneSpec: tuneSpecInput, pluginDigests: Object.values(loaded.pluginDigest), ...engineIdentity }
     });
     const outputMeta = buildOutputMeta({
       command: "tune",
@@ -42269,7 +42531,7 @@ var tune_default = defineCommand({
       pluginDigest: loaded.pluginDigest
     });
     const result = await cmdTune({
-      E: createNumberEngine(),
+      E: engine.engine,
       scenarioInput,
       tuneSpecInput,
       modelRegistry: loaded.modelRegistry,
@@ -44186,4 +44448,4 @@ export {
   cli2 as cli
 };
 
-//# debugId=A3CAAFDF1955C7F064756E2164756E21
+//# debugId=0936659FB5366DD764756E2164756E21