@idlekit/cli 0.5.1 → 0.7.0

package/dist/main.js

@@ -6605,6 +6605,69 @@ var require_src = __commonJS(function(exports, module) {
   module.exports = { cursor, scroll, erase, beep };
 });
 
+// src/runtime/invocation.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { resolve } from "path";
+function runWithInvocation(invocation, fn) {
+  return storage.run({ ...invocation, reads: new Set }, fn);
+}
+function recordInputRead(path) {
+  storage.getStore()?.reads.add(resolve(path));
+}
+function flagPaths(key, value) {
+  if (typeof value !== "string" || !value.trim())
+    return [];
+  if (LIST_FLAGS.has(key))
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+  return INPUT_FLAGS.has(key) ? [value] : [];
+}
+function recordNestedInputs(base, positional, flags) {
+  for (const value of positional)
+    if (value.length > 0)
+      recordInputRead(resolve(base, value));
+  for (const [key, value] of Object.entries(flags))
+    for (const path of flagPaths(key, value))
+      recordInputRead(resolve(base, path));
+}
+function invocationInputCandidates(options = {}) {
+  const invocation = storage.getStore();
+  if (!invocation)
+    return [];
+  const allow = new Set(options.allow ?? []);
+  const allowed = new Set;
+  const candidates = [];
+  for (const [key, value] of Object.entries(invocation.flags)) {
+    const paths = flagPaths(key, value);
+    if (allow.has(key))
+      for (const path of paths)
+        allowed.add(resolve(path));
+    else
+      candidates.push(...paths);
+  }
+  for (const path of invocation.reads)
+    if (!allowed.has(path))
+      candidates.push(path);
+  return candidates;
+}
+var INPUT_FLAGS, LIST_FLAGS, storage;
+var init_invocation = __esm(() => {
+  INPUT_FLAGS = new Set([
+    "scenario",
+    "baseline",
+    "current",
+    "baseline-artifact",
+    "tune",
+    "checks",
+    "rubric",
+    "cache",
+    "resume",
+    "rc",
+    "plugin-trust-file"
+  ]);
+  LIST_FLAGS = new Set(["plugin"]);
+  storage = new AsyncLocalStorage;
+});
+
 // ../core/dist/engine/types.js
 var init_types = () => {};
 
@@ -8397,7 +8460,7 @@ var init_validate = __esm(() => {
   OFFLINE_ACTORS = new Set(["player", "automation"]);
 });
 
-// ../../node_modules/.bun/typia@15.1.0+367f7514c87f1df1/node_modules/typia/lib/internal/_validateReport.mjs
+// ../../node_modules/.bun/typia@15.2.2+38c91d72aa8392f2/node_modules/typia/lib/internal/_validateReport.mjs
 var _validateReport = (array) => {
   const isAncestor = (ancestor, descendant) => descendant === ancestor || descendant.startsWith(`${ancestor}.`) || descendant.startsWith(`${ancestor}[`);
   const reportable = (path) => {
@@ -8422,7 +8485,7 @@ var _validateReport = (array) => {
 };
 var init__validateReport = () => {};
 
-// ../../node_modules/.bun/typia@15.1.0+367f7514c87f1df1/node_modules/typia/lib/internal/_createStandardSchema.mjs
+// ../../node_modules/.bun/typia@15.2.2+38c91d72aa8392f2/node_modules/typia/lib/internal/_createStandardSchema.mjs
 var _createStandardSchema = (fn) => Object.assign(fn, { "~standard": {
   version: 1,
   vendor: "typia",
@@ -10693,6 +10756,14 @@ var init_goalRead = __esm(() => {
   ledgers = new WeakMap;
 });
 
+// ../core/dist/sim/milestoneKeys.js
+function actionMilestoneKeys(actionId) {
+  return [`action.${actionId}.firstApplied`, "progress.first-upgrade"];
+}
+function mayRecordAtActionStart(key) {
+  return key === "progress.first-upgrade" || key.startsWith("action.") && key.endsWith(".firstApplied");
+}
+
 // ../core/dist/sim/observation.js
 function emitCommittedResets(observer, resets) {
   if (!observer?.onReset || resets.length === 0)
@@ -10873,7 +10944,11 @@ function createObservationRecorder(args) {
       milestones.push(sample);
     }
     if (args.observer?.onMilestone) {
-      notify(() => args.observer?.onMilestone?.({ t: sample.firstSeenT, key: sample.key }));
+      notify(() => args.observer?.onMilestone?.({
+        t: sample.firstSeenT,
+        key: sample.key,
+        phase: sample.source === "action" ? "action-start" : "income-end"
+      }));
     }
   };
   const open = (goal) => !reachedGoals.has(goal.id) && !droppedGoals.has(goal.id);
@@ -10931,8 +11006,8 @@ function createObservationRecorder(args) {
           if (args.observer?.onAction) {
             notify(() => args.observer?.onAction?.({ t: step.t0, actionId: event.actionId, outcome: "applied" }));
           }
-          rememberMilestone({ key: `action.${event.actionId}.firstApplied`, firstSeenT: step.t0, source: "action" });
-          rememberMilestone({ key: "progress.first-upgrade", firstSeenT: step.t0, source: "action" });
+          for (const key of actionMilestoneKeys(event.actionId))
+            rememberMilestone({ key, firstSeenT: step.t0, source: "action" });
         } else if (event.type === "action.skipped") {
           if (event.reason === "cannotApply")
             actions.skippedCannotApply += 1;
@@ -11605,6 +11680,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 +11832,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 +11921,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 +11945,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 +12125,7 @@ var init_session = __esm(() => {
   init_goalRead();
   init_observation();
   init_offline();
+  init_sessionOffline();
   init_simulator();
 });
 
@@ -12972,11 +13121,20 @@ 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 ZERO_AMOUNT_LOG10_FLOOR;
+  if (!Number.isFinite(value))
+    throw new RangeError("Tuning requires a finite monetary logarithm");
+  return Math.max(ZERO_AMOUNT_LOG10_FLOOR, value);
 }
+var ZERO_AMOUNT_LOG10_FLOOR = -300;
+
+// ../core/dist/sim/strategy/opt/objectives/builtins.js
 var builtinObjectiveFactories;
 var init_builtins2 = __esm(() => {
   init_parseMoney2();
@@ -12990,7 +13148,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 +13161,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 +13176,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 +13190,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 +13205,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 +13231,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 +13263,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 +13462,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 +13547,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 +14555,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 +14705,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;
@@ -15038,15 +15240,16 @@ function readBenefit(vars) {
   const value = vars.benefit;
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
-function observeMetrics(E, spec, end, startT, reachedAt, elapsedSec) {
+function observeMetrics(E, spec, end, moneyElapsedSec, milestoneElapsedSec, elapsedSec) {
   const amount = end.wallet.money.amount;
   const benefit = readBenefit(end.vars);
   return metricIds(spec).map((metricId) => {
-    if (metricId === "timeToMoney") {
-      if (reachedAt === undefined) {
-        return { metricId, status: "censored", value: null, lowerBound: { sec: elapsedSec, strict: true } };
+    if (metricId === "timeToMoney" || metricId === "timeToMilestone") {
+      const elapsed = metricId === "timeToMoney" ? moneyElapsedSec : milestoneElapsedSec;
+      if (elapsed === undefined) {
+        const strict = metricId === "timeToMoney" || !mayRecordAtActionStart(spec.milestoneKey ?? "");
+        return { metricId, status: "censored", value: null, lowerBound: { sec: elapsedSec, strict } };
       }
-      const elapsed = reachedAt - startT;
       return { metricId, status: "observed", value: String(elapsed), num: elapsed };
     }
     if (metricId === "endMoney") {
@@ -15069,7 +15272,7 @@ function aggregate(E, rows, metricId) {
   }
   if (picked.some((metric) => metric.status !== "observed" || metric.value === null)) {
     const bounded = picked.every((metric) => metric.num !== undefined || metric.lowerBound !== undefined);
-    if (metricId !== "timeToMoney" || !bounded)
+    if (metricId !== "timeToMoney" && metricId !== "timeToMilestone" || !bounded)
       return { metricId, status: "censored", value: null };
     const bounds = picked.map((metric) => metric.num ?? metric.lowerBound.sec);
     const total = bounds.reduce((sum, bound) => sum + bound, 0);
@@ -15156,6 +15359,10 @@ function prepareExperiment(request) {
     reject("goal target must be finite");
   if (metrics.includes("timeToMoney") && spec.goal === undefined)
     reject("timeToMoney requires a finite goal target");
+  if (spec.milestoneKey !== undefined && spec.milestoneKey.trim().length === 0)
+    reject("milestoneKey must not be blank");
+  if (metrics.includes("timeToMilestone") && spec.milestoneKey === undefined)
+    reject("timeToMilestone requires milestoneKey");
   if (!isJsonData(request.spec, new Set, true))
     reject("spec must be JSON data, because the spec hashes record it as JSON");
   requireScenarioData(request.scenario);
@@ -15182,7 +15389,8 @@ function checkExperimentSpec(request) {
 }
 function runExperiment(request) {
   const { spec, metrics, base, prepared, specHashes } = prepareExperiment(request);
-  const measuresReach = metrics.includes("timeToMoney");
+  const measuresMoney = metrics.includes("timeToMoney");
+  const measuresMilestone = metrics.includes("timeToMilestone");
   const E = request.engine;
   const { strategy: _scenarioStrategy, ...withoutStrategy } = request.scenario;
   const compiled = compileScenario({
@@ -15201,7 +15409,7 @@ function runExperiment(request) {
     models: request.modelRegistry,
     strategies: request.strategyRegistry
   });
-  const target = measuresReach && spec.goal !== undefined ? E.from(spec.goal.target) : undefined;
+  const target = measuresMoney && spec.goal !== undefined ? E.from(spec.goal.target) : undefined;
   const stopAtReach = metrics.every((metricId) => metricId === "timeToMoney");
   const tasks = [];
   const perCandidate = [];
@@ -15226,21 +15434,41 @@ function runExperiment(request) {
       try {
         const opened = binding.fresh({ trialId: taskId, seed, plan });
         const scenario = opened.scenario;
-        let reachedAt;
+        let moneyElapsedSec;
+        let milestoneElapsedSec;
+        let observedElapsedSec = 0;
+        let stepStartElapsedSec = 0;
         const result = runScenario({
           ...scenario,
           run: {
             ...scenario.run,
+            ...measuresMoney || measuresMilestone ? {
+              observation: { ...scenario.run.observation, enabled: true, ...measuresMilestone ? { maxMilestones: 0 } : {} },
+              observer: {
+                ...scenario.run.observer,
+                onStep: (fact) => {
+                  stepStartElapsedSec = observedElapsedSec;
+                  observedElapsedSec += fact.dt;
+                  scenario.run.observer?.onStep?.(fact);
+                },
+                onMilestone: (fact) => {
+                  if (measuresMilestone && milestoneElapsedSec === undefined && fact.key === spec.milestoneKey) {
+                    milestoneElapsedSec = fact.phase === "action-start" ? stepStartElapsedSec : observedElapsedSec;
+                  }
+                  scenario.run.observer?.onMilestone?.(fact);
+                }
+              }
+            } : {},
             ...target !== undefined ? {
               until: (state) => {
-                if (reachedAt === undefined && E.cmp(state.wallet.money.amount, target) >= 0)
-                  reachedAt = state.t;
-                return stopAtReach && reachedAt !== undefined;
+                if (moneyElapsedSec === undefined && E.cmp(state.wallet.money.amount, target) >= 0)
+                  moneyElapsedSec = observedElapsedSec;
+                return stopAtReach && moneyElapsedSec !== undefined;
               }
             } : {}
           }
         });
-        readings = observeMetrics(E, spec, result.end, result.start.t, reachedAt, runElapsedSec(result));
+        readings = observeMetrics(E, spec, result.end, moneyElapsedSec, milestoneElapsedSec, runElapsedSec(result));
       } catch {
         readings = failedMetrics(spec);
       }
@@ -15328,6 +15556,7 @@ function runExperiment(request) {
     originalSpecHash: specHashes.original,
     effectiveSpecHash: specHashes.effective,
     effectiveRunHash: request.effectiveRunHash,
+    ...measuresMilestone ? { milestoneKey: spec.milestoneKey } : {},
     budget: {
       candidates: spec.budget.candidates,
       seeds: spec.budget.seeds,
@@ -15357,30 +15586,31 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
   const _ip8 = (input) => typeof input["originalSpecHash"] === "string";
   const _ip9 = (input) => typeof input["effectiveSpecHash"] === "string";
   const _ip10 = (input) => typeof input["effectiveRunHash"] === "string";
-  const _ip11 = (input) => typeof input["budget"] === "object" && input["budget"] !== null && _io2(input["budget"]);
-  const _ip12 = (input) => Array.isArray(input["tasks"]) && input["tasks"].every((elem) => typeof elem === "object" && elem !== null && _io3(elem));
-  const _ip13 = (input) => Array.isArray(input["candidates"]) && input["candidates"].every((elem) => typeof elem === "object" && elem !== null && _io4(elem));
-  const _ip14 = (input) => Array.isArray(input["elasticities"]) && input["elasticities"].every((elem) => typeof elem === "object" && elem !== null && _io6(elem));
-  const _ip15 = (input) => typeof input["pareto"] === "object" && input["pareto"] !== null && _io7(input["pareto"]);
-  const _ip16 = (input) => Array.isArray(input["warnings"]) && input["warnings"].every((elem) => typeof elem === "string");
-  const _ip17 = (input) => typeof input["taskId"] === "string";
-  const _ip18 = (input) => typeof input["candidateId"] === "string";
-  const _ip19 = (input) => typeof input["logicalSeed"] === "number";
-  const _ip20 = (input) => typeof input["engineId"] === "string";
-  const _ip21 = (input) => typeof input["engineVersion"] === "string";
-  const _ip22 = (input) => typeof input["modelId"] === "string";
-  const _ip23 = (input) => typeof input["modelVersion"] === "number";
-  const _ip24 = (input) => input["strategyId"] === null || typeof input["strategyId"] === "string";
-  const _ip25 = (input) => typeof input["modelParams"] === "string";
-  const _ip26 = (input) => typeof input["strategyParams"] === "string";
-  const _ip27 = (input) => typeof input["sessionPattern"] === "string";
-  const _ip28 = (input) => typeof input["sessionDays"] === "number";
-  const _ip29 = (input) => typeof input["horizonSec"] === "number";
-  const _ip30 = (input) => typeof input["stepSec"] === "number";
-  const _ip31 = (input) => input["metricId"] === "endMoney" || input["metricId"] === "timeToMoney" || input["metricId"] === "varBenefit";
-  const _ip32 = (input) => input["status"] === "censored" || input["status"] === "failed" || input["status"] === "observed" || input["status"] === "rejected";
-  const _ip33 = (input) => input["value"] === null || typeof input["value"] === "string";
-  const _ve0 = 'Readonly<{ schemaVersion: 1; contract: "idlekit.experiment.v1"; estimatorVersion: "one-at-a-time-local-v1"; algorithmVersion: "experiment-oat-v1"; method: "fixed-sweep-and-one-at-a-time"; ... 11 more ...; warnings: readonly string[]; }>';
+  const _ip11 = (input) => input["milestoneKey"] === undefined || typeof input["milestoneKey"] === "string";
+  const _ip12 = (input) => typeof input["budget"] === "object" && input["budget"] !== null && _io2(input["budget"]);
+  const _ip13 = (input) => Array.isArray(input["tasks"]) && input["tasks"].every((elem) => typeof elem === "object" && elem !== null && _io3(elem));
+  const _ip14 = (input) => Array.isArray(input["candidates"]) && input["candidates"].every((elem) => typeof elem === "object" && elem !== null && _io4(elem));
+  const _ip15 = (input) => Array.isArray(input["elasticities"]) && input["elasticities"].every((elem) => typeof elem === "object" && elem !== null && _io6(elem));
+  const _ip16 = (input) => typeof input["pareto"] === "object" && input["pareto"] !== null && _io7(input["pareto"]);
+  const _ip17 = (input) => Array.isArray(input["warnings"]) && input["warnings"].every((elem) => typeof elem === "string");
+  const _ip18 = (input) => typeof input["taskId"] === "string";
+  const _ip19 = (input) => typeof input["candidateId"] === "string";
+  const _ip20 = (input) => typeof input["logicalSeed"] === "number";
+  const _ip21 = (input) => typeof input["engineId"] === "string";
+  const _ip22 = (input) => typeof input["engineVersion"] === "string";
+  const _ip23 = (input) => typeof input["modelId"] === "string";
+  const _ip24 = (input) => typeof input["modelVersion"] === "number";
+  const _ip25 = (input) => input["strategyId"] === null || typeof input["strategyId"] === "string";
+  const _ip26 = (input) => typeof input["modelParams"] === "string";
+  const _ip27 = (input) => typeof input["strategyParams"] === "string";
+  const _ip28 = (input) => typeof input["sessionPattern"] === "string";
+  const _ip29 = (input) => typeof input["sessionDays"] === "number";
+  const _ip30 = (input) => typeof input["horizonSec"] === "number";
+  const _ip31 = (input) => typeof input["stepSec"] === "number";
+  const _ip32 = (input) => input["metricId"] === "endMoney" || input["metricId"] === "timeToMilestone" || input["metricId"] === "timeToMoney" || input["metricId"] === "varBenefit";
+  const _ip33 = (input) => input["status"] === "censored" || input["status"] === "failed" || input["status"] === "observed" || input["status"] === "rejected";
+  const _ip34 = (input) => input["value"] === null || typeof input["value"] === "string";
+  const _ve0 = 'Readonly<{ schemaVersion: 1; contract: "idlekit.experiment.v1"; estimatorVersion: "one-at-a-time-local-v1"; algorithmVersion: "experiment-oat-v1"; method: "fixed-sweep-and-one-at-a-time"; ... 12 more ...; warnings: readonly string[]; }>';
   const _vp0 = (input, _path, _exceptionable = true) => input["schemaVersion"] === 1 || _report(_exceptionable, {
     path: _path + ".schemaVersion",
     expected: "1",
@@ -15440,7 +15670,12 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     expected: "string",
     value: input["effectiveRunHash"]
   });
-  const _vp11 = (input, _path, _exceptionable = true) => (typeof input["budget"] === "object" && input["budget"] !== null || _report(_exceptionable, {
+  const _vp11 = (input, _path, _exceptionable = true) => input["milestoneKey"] === undefined || typeof input["milestoneKey"] === "string" || _report(_exceptionable, {
+    path: _path + ".milestoneKey",
+    expected: "(string | undefined)",
+    value: input["milestoneKey"]
+  });
+  const _vp12 = (input, _path, _exceptionable = true) => (typeof input["budget"] === "object" && input["budget"] !== null || _report(_exceptionable, {
     path: _path + ".budget",
     expected: "Readonly<{ candidates: number; seeds: number; usedCandidates: number; usedSeeds: number; }>",
     value: input["budget"]
@@ -15449,7 +15684,7 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     expected: "Readonly<{ candidates: number; seeds: number; usedCandidates: number; usedSeeds: number; }>",
     value: input["budget"]
   });
-  const _vp12 = (input, _path, _exceptionable = true) => (Array.isArray(input["tasks"]) || _report(_exceptionable, {
+  const _vp13 = (input, _path, _exceptionable = true) => (Array.isArray(input["tasks"]) || _report(_exceptionable, {
     path: _path + ".tasks",
     expected: _ve2,
     value: input["tasks"]
@@ -15468,7 +15703,7 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
   });
   const _ve1 = "Readonly<{ taskId: string; candidateId: string; logicalSeed: number; engineId: string; engineVersion: string; modelId: string; modelVersion: number; strategyId: string | null; modelParams: string; ... 7 more ...; value: string | null; }>";
   const _ve2 = "ReadonlyArray<Readonly<{ taskId: string; candidateId: string; logicalSeed: number; engineId: string; engineVersion: string; modelId: string; modelVersion: number; strategyId: string | null; modelParams: string; ... 7 more ...; value: string | null; }>>";
-  const _vp13 = (input, _path, _exceptionable = true) => (Array.isArray(input["candidates"]) || _report(_exceptionable, {
+  const _vp14 = (input, _path, _exceptionable = true) => (Array.isArray(input["candidates"]) || _report(_exceptionable, {
     path: _path + ".candidates",
     expected: _ve4,
     value: input["candidates"]
@@ -15487,7 +15722,7 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
   });
   const _ve3 = "Readonly<{ id: string; metrics: readonly Readonly<{ metricId: ExperimentMetricId; status: ExperimentMetricStatus; value: string | null; }>[]; constraintViolations: readonly string[]; }>";
   const _ve4 = "ReadonlyArray<Readonly<{ id: string; metrics: readonly Readonly<{ metricId: ExperimentMetricId; status: ExperimentMetricStatus; value: string | null; }>[]; constraintViolations: readonly string[]; }>>";
-  const _vp14 = (input, _path, _exceptionable = true) => (Array.isArray(input["elasticities"]) || _report(_exceptionable, {
+  const _vp15 = (input, _path, _exceptionable = true) => (Array.isArray(input["elasticities"]) || _report(_exceptionable, {
     path: _path + ".elasticities",
     expected: _ve6,
     value: input["elasticities"]
@@ -15506,7 +15741,7 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
   });
   const _ve5 = 'Readonly<{ dimensionId: string; candidateId: string; metricId: ExperimentMetricId; method: "one-at-a-time-local"; methodVersion: 1; globalSensitivity: false; sobol: false; status: "observed" | "unavailable"; elasticity: string | null; absoluteChange: string | null; direction: "flat" | ... 2 more ... | "unavailable";...';
   const _ve6 = 'ReadonlyArray<Readonly<{ dimensionId: string; candidateId: string; metricId: ExperimentMetricId; method: "one-at-a-time-local"; methodVersion: 1; globalSensitivity: false; sobol: false; status: "observed" | "unavailable"; elasticity: string | null; absoluteChange: string | null; direction: "flat" | ... 2 more ... | "unavailable";...>';
-  const _vp15 = (input, _path, _exceptionable = true) => (typeof input["pareto"] === "object" && input["pareto"] !== null || _report(_exceptionable, {
+  const _vp16 = (input, _path, _exceptionable = true) => (typeof input["pareto"] === "object" && input["pareto"] !== null || _report(_exceptionable, {
     path: _path + ".pareto",
     expected: 'Readonly<{ sense: "per-metric"; nonDominated: readonly string[]; uncompared: readonly string[]; }>',
     value: input["pareto"]
@@ -15515,7 +15750,7 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     expected: 'Readonly<{ sense: "per-metric"; nonDominated: readonly string[]; uncompared: readonly string[]; }>',
     value: input["pareto"]
   });
-  const _vp16 = (input, _path, _exceptionable = true) => (Array.isArray(input["warnings"]) || _report(_exceptionable, {
+  const _vp17 = (input, _path, _exceptionable = true) => (Array.isArray(input["warnings"]) || _report(_exceptionable, {
     path: _path + ".warnings",
     expected: "ReadonlyArray<string>",
     value: input["warnings"]
@@ -15528,100 +15763,100 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     expected: "ReadonlyArray<string>",
     value: input["warnings"]
   });
-  const _vp17 = (input, _path, _exceptionable = true) => typeof input["taskId"] === "string" || _report(_exceptionable, {
+  const _vp18 = (input, _path, _exceptionable = true) => typeof input["taskId"] === "string" || _report(_exceptionable, {
     path: _path + ".taskId",
     expected: "string",
     value: input["taskId"]
   });
-  const _vp18 = (input, _path, _exceptionable = true) => typeof input["candidateId"] === "string" || _report(_exceptionable, {
+  const _vp19 = (input, _path, _exceptionable = true) => typeof input["candidateId"] === "string" || _report(_exceptionable, {
     path: _path + ".candidateId",
     expected: "string",
     value: input["candidateId"]
   });
-  const _vp19 = (input, _path, _exceptionable = true) => typeof input["logicalSeed"] === "number" || _report(_exceptionable, {
+  const _vp20 = (input, _path, _exceptionable = true) => typeof input["logicalSeed"] === "number" || _report(_exceptionable, {
     path: _path + ".logicalSeed",
     expected: "number",
     value: input["logicalSeed"]
   });
-  const _vp20 = (input, _path, _exceptionable = true) => typeof input["engineId"] === "string" || _report(_exceptionable, {
+  const _vp21 = (input, _path, _exceptionable = true) => typeof input["engineId"] === "string" || _report(_exceptionable, {
     path: _path + ".engineId",
     expected: "string",
     value: input["engineId"]
   });
-  const _vp21 = (input, _path, _exceptionable = true) => typeof input["engineVersion"] === "string" || _report(_exceptionable, {
+  const _vp22 = (input, _path, _exceptionable = true) => typeof input["engineVersion"] === "string" || _report(_exceptionable, {
     path: _path + ".engineVersion",
     expected: "string",
     value: input["engineVersion"]
   });
-  const _vp22 = (input, _path, _exceptionable = true) => typeof input["modelId"] === "string" || _report(_exceptionable, {
+  const _vp23 = (input, _path, _exceptionable = true) => typeof input["modelId"] === "string" || _report(_exceptionable, {
     path: _path + ".modelId",
     expected: "string",
     value: input["modelId"]
   });
-  const _vp23 = (input, _path, _exceptionable = true) => typeof input["modelVersion"] === "number" || _report(_exceptionable, {
+  const _vp24 = (input, _path, _exceptionable = true) => typeof input["modelVersion"] === "number" || _report(_exceptionable, {
     path: _path + ".modelVersion",
     expected: "number",
     value: input["modelVersion"]
   });
-  const _vp24 = (input, _path, _exceptionable = true) => input["strategyId"] === null || typeof input["strategyId"] === "string" || _report(_exceptionable, {
+  const _vp25 = (input, _path, _exceptionable = true) => input["strategyId"] === null || typeof input["strategyId"] === "string" || _report(_exceptionable, {
     path: _path + ".strategyId",
     expected: "(null | string)",
     value: input["strategyId"]
   });
-  const _vp25 = (input, _path, _exceptionable = true) => typeof input["modelParams"] === "string" || _report(_exceptionable, {
+  const _vp26 = (input, _path, _exceptionable = true) => typeof input["modelParams"] === "string" || _report(_exceptionable, {
     path: _path + ".modelParams",
     expected: "string",
     value: input["modelParams"]
   });
-  const _vp26 = (input, _path, _exceptionable = true) => typeof input["strategyParams"] === "string" || _report(_exceptionable, {
+  const _vp27 = (input, _path, _exceptionable = true) => typeof input["strategyParams"] === "string" || _report(_exceptionable, {
     path: _path + ".strategyParams",
     expected: "string",
     value: input["strategyParams"]
   });
-  const _vp27 = (input, _path, _exceptionable = true) => typeof input["sessionPattern"] === "string" || _report(_exceptionable, {
+  const _vp28 = (input, _path, _exceptionable = true) => typeof input["sessionPattern"] === "string" || _report(_exceptionable, {
     path: _path + ".sessionPattern",
     expected: "string",
     value: input["sessionPattern"]
   });
-  const _vp28 = (input, _path, _exceptionable = true) => typeof input["sessionDays"] === "number" || _report(_exceptionable, {
+  const _vp29 = (input, _path, _exceptionable = true) => typeof input["sessionDays"] === "number" || _report(_exceptionable, {
     path: _path + ".sessionDays",
     expected: "number",
     value: input["sessionDays"]
   });
-  const _vp29 = (input, _path, _exceptionable = true) => typeof input["horizonSec"] === "number" || _report(_exceptionable, {
+  const _vp30 = (input, _path, _exceptionable = true) => typeof input["horizonSec"] === "number" || _report(_exceptionable, {
     path: _path + ".horizonSec",
     expected: "number",
     value: input["horizonSec"]
   });
-  const _vp30 = (input, _path, _exceptionable = true) => typeof input["stepSec"] === "number" || _report(_exceptionable, {
+  const _vp31 = (input, _path, _exceptionable = true) => typeof input["stepSec"] === "number" || _report(_exceptionable, {
     path: _path + ".stepSec",
     expected: "number",
     value: input["stepSec"]
   });
-  const _vp31 = (input, _path, _exceptionable = true) => input["metricId"] === "endMoney" || input["metricId"] === "timeToMoney" || input["metricId"] === "varBenefit" || _report(_exceptionable, {
+  const _vp32 = (input, _path, _exceptionable = true) => input["metricId"] === "endMoney" || input["metricId"] === "timeToMilestone" || input["metricId"] === "timeToMoney" || input["metricId"] === "varBenefit" || _report(_exceptionable, {
     path: _path + ".metricId",
-    expected: '("endMoney" | "timeToMoney" | "varBenefit")',
+    expected: '("endMoney" | "timeToMilestone" | "timeToMoney" | "varBenefit")',
     value: input["metricId"]
   });
-  const _vp32 = (input, _path, _exceptionable = true) => input["status"] === "censored" || input["status"] === "failed" || input["status"] === "observed" || input["status"] === "rejected" || _report(_exceptionable, {
+  const _vp33 = (input, _path, _exceptionable = true) => input["status"] === "censored" || input["status"] === "failed" || input["status"] === "observed" || input["status"] === "rejected" || _report(_exceptionable, {
     path: _path + ".status",
     expected: '("censored" | "failed" | "observed" | "rejected")',
     value: input["status"]
   });
-  const _vp33 = (input, _path, _exceptionable = true) => input["value"] === null || typeof input["value"] === "string" || _report(_exceptionable, {
+  const _vp34 = (input, _path, _exceptionable = true) => input["value"] === null || typeof input["value"] === "string" || _report(_exceptionable, {
     path: _path + ".value",
     expected: "(null | string)",
     value: input["value"]
   });
-  const _io0 = (input) => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && _ip7(input) && _ip8(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip13(input) && _ip14(input) && _ip15(input) && _ip16(input);
+  const _io0 = (input) => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && _ip7(input) && _ip8(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip13(input) && _ip14(input) && _ip15(input) && _ip16(input) && _ip17(input);
   const _io1 = (input) => typeof input.ref === "string" && typeof input.hash === "string";
   const _io2 = (input) => typeof input.candidates === "number" && typeof input.seeds === "number" && typeof input.usedCandidates === "number" && typeof input.usedSeeds === "number";
-  const _io3 = (input) => _ip17(input) && _ip18(input) && _ip19(input) && _ip20(input) && _ip21(input) && _ip22(input) && _ip23(input) && _ip24(input) && _ip25(input) && _ip26(input) && _ip27(input) && _ip28(input) && _ip29(input) && _ip30(input) && _ip31(input) && _ip32(input) && _ip33(input);
+  const _io3 = (input) => _ip18(input) && _ip19(input) && _ip20(input) && _ip21(input) && _ip22(input) && _ip23(input) && _ip24(input) && _ip25(input) && _ip26(input) && _ip27(input) && _ip28(input) && _ip29(input) && _ip30(input) && _ip31(input) && _ip32(input) && _ip33(input) && _ip34(input);
   const _io4 = (input) => typeof input.id === "string" && (Array.isArray(input.metrics) && input.metrics.every((elem) => typeof elem === "object" && elem !== null && _io5(elem))) && (Array.isArray(input.constraintViolations) && input.constraintViolations.every((elem) => typeof elem === "string"));
-  const _io5 = (input) => _ip31(input) && _ip32(input) && _ip33(input);
-  const _io6 = (input) => typeof input.dimensionId === "string" && _ip18(input) && _ip31(input) && input.method === "one-at-a-time-local" && input.methodVersion === 1 && _ip5(input) && _ip6(input) && (input.status === "observed" || input.status === "unavailable") && (input.elasticity === null || typeof input.elasticity === "string") && (input.absoluteChange === null || typeof input.absoluteChange === "string") && (input.direction === "flat" || input.direction === "higher" || input.direction === "lower" || input.direction === "unavailable");
+  const _io5 = (input) => _ip32(input) && _ip33(input) && _ip34(input);
+  const _io6 = (input) => typeof input.dimensionId === "string" && _ip19(input) && _ip32(input) && input.method === "one-at-a-time-local" && input.methodVersion === 1 && _ip5(input) && _ip6(input) && (input.status === "observed" || input.status === "unavailable") && (input.elasticity === null || typeof input.elasticity === "string") && (input.absoluteChange === null || typeof input.absoluteChange === "string") && (input.direction === "flat" || input.direction === "higher" || input.direction === "lower" || input.direction === "unavailable");
   const _io7 = (input) => input.sense === "per-metric" && (Array.isArray(input.nonDominated) && input.nonDominated.every((elem) => typeof elem === "string")) && (Array.isArray(input.uncompared) && input.uncompared.every((elem) => typeof elem === "string"));
-  const _vo0 = (input, _path, _exceptionable = true) => [_vp0(input, _path, _exceptionable), _vp1(input, _path, _exceptionable), _vp2(input, _path, _exceptionable), _vp3(input, _path, _exceptionable), _vp4(input, _path, _exceptionable), _vp5(input, _path, _exceptionable), _vp6(input, _path, _exceptionable), _vp7(input, _path, _exceptionable), _vp8(input, _path, _exceptionable), _vp9(input, _path, _exceptionable), _vp10(input, _path, _exceptionable), _vp11(input, _path, _exceptionable), _vp12(input, _path, _exceptionable), _vp13(input, _path, _exceptionable), _vp14(input, _path, _exceptionable), _vp15(input, _path, _exceptionable), _vp16(input, _path, _exceptionable)].every((flag) => flag);
+  const _vo0 = (input, _path, _exceptionable = true) => [_vp0(input, _path, _exceptionable), _vp1(input, _path, _exceptionable), _vp2(input, _path, _exceptionable), _vp3(input, _path, _exceptionable), _vp4(input, _path, _exceptionable), _vp5(input, _path, _exceptionable), _vp6(input, _path, _exceptionable), _vp7(input, _path, _exceptionable), _vp8(input, _path, _exceptionable), _vp9(input, _path, _exceptionable), _vp10(input, _path, _exceptionable), _vp11(input, _path, _exceptionable), _vp12(input, _path, _exceptionable), _vp13(input, _path, _exceptionable), _vp14(input, _path, _exceptionable), _vp15(input, _path, _exceptionable), _vp16(input, _path, _exceptionable), _vp17(input, _path, _exceptionable)].every((flag) => flag);
   const _vo1 = (input, _path, _exceptionable = true) => [typeof input.ref === "string" || _report(_exceptionable, {
     path: _path + ".ref",
     expected: "string",
@@ -15648,7 +15883,7 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     expected: "number",
     value: input.usedSeeds
   })].every((flag) => flag);
-  const _vo3 = (input, _path, _exceptionable = true) => [_vp17(input, _path, _exceptionable), _vp18(input, _path, _exceptionable), _vp19(input, _path, _exceptionable), _vp20(input, _path, _exceptionable), _vp21(input, _path, _exceptionable), _vp22(input, _path, _exceptionable), _vp23(input, _path, _exceptionable), _vp24(input, _path, _exceptionable), _vp25(input, _path, _exceptionable), _vp26(input, _path, _exceptionable), _vp27(input, _path, _exceptionable), _vp28(input, _path, _exceptionable), _vp29(input, _path, _exceptionable), _vp30(input, _path, _exceptionable), _vp31(input, _path, _exceptionable), _vp32(input, _path, _exceptionable), _vp33(input, _path, _exceptionable)].every((flag) => flag);
+  const _vo3 = (input, _path, _exceptionable = true) => [_vp18(input, _path, _exceptionable), _vp19(input, _path, _exceptionable), _vp20(input, _path, _exceptionable), _vp21(input, _path, _exceptionable), _vp22(input, _path, _exceptionable), _vp23(input, _path, _exceptionable), _vp24(input, _path, _exceptionable), _vp25(input, _path, _exceptionable), _vp26(input, _path, _exceptionable), _vp27(input, _path, _exceptionable), _vp28(input, _path, _exceptionable), _vp29(input, _path, _exceptionable), _vp30(input, _path, _exceptionable), _vp31(input, _path, _exceptionable), _vp32(input, _path, _exceptionable), _vp33(input, _path, _exceptionable), _vp34(input, _path, _exceptionable)].every((flag) => flag);
   const _vo4 = (input, _path, _exceptionable = true) => [typeof input.id === "string" || _report(_exceptionable, {
     path: _path + ".id",
     expected: "string",
@@ -15682,12 +15917,12 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     expected: "ReadonlyArray<string>",
     value: input.constraintViolations
   })].every((flag) => flag);
-  const _vo5 = (input, _path, _exceptionable = true) => [_vp31(input, _path, _exceptionable), _vp32(input, _path, _exceptionable), _vp33(input, _path, _exceptionable)].every((flag) => flag);
+  const _vo5 = (input, _path, _exceptionable = true) => [_vp32(input, _path, _exceptionable), _vp33(input, _path, _exceptionable), _vp34(input, _path, _exceptionable)].every((flag) => flag);
   const _vo6 = (input, _path, _exceptionable = true) => [typeof input.dimensionId === "string" || _report(_exceptionable, {
     path: _path + ".dimensionId",
     expected: "string",
     value: input.dimensionId
-  }), _vp18(input, _path, _exceptionable), _vp31(input, _path, _exceptionable), input.method === "one-at-a-time-local" || _report(_exceptionable, {
+  }), _vp19(input, _path, _exceptionable), _vp32(input, _path, _exceptionable), input.method === "one-at-a-time-local" || _report(_exceptionable, {
     path: _path + ".method",
     expected: '"one-at-a-time-local"',
     value: input.method
@@ -15773,105 +16008,82 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     };
   });
 })())(input), validateExperimentSpecValidator, validateExperimentSpec = (input) => (validateExperimentSpecValidator ??= (() => {
-  const _ip0 = (input) => input["metricId"] === "endMoney" || input["metricId"] === "timeToMoney" || input["metricId"] === "varBenefit";
-  const _ip1 = (input) => typeof input["id"] === "string";
-  const _ip2 = (input) => typeof input["min"] === "number";
-  const _ip3 = (input) => typeof input["max"] === "number";
-  const _ve0 = "Readonly<{ schemaVersion: 1; scenario: Readonly<{ ref: string; hash: string; }>; model: Readonly<{ id: string; version: number; }>; strategy?: Readonly<{ id: string; }> | undefined; ... 10 more ...; session: Readonly<...>; }>";
-  const _vp0 = (input, _path, _exceptionable = true) => input["metricId"] === "endMoney" || input["metricId"] === "timeToMoney" || input["metricId"] === "varBenefit" || _report(_exceptionable, {
-    path: _path + ".metricId",
-    expected: '("endMoney" | "timeToMoney" | "varBenefit")',
-    value: input["metricId"]
-  });
-  const _ve1 = 'Readonly<{ id: string; target: "model" | "session" | "strategy"; path: string; space: ExperimentParamSpace; baseline: ExperimentScalar; probes?: readonly ExperimentScalar[] | undefined; }>';
-  const _ve2 = 'ReadonlyArray<Readonly<{ id: string; target: "model" | "session" | "strategy"; path: string; space: ExperimentParamSpace; baseline: ExperimentScalar; probes?: readonly ExperimentScalar[] | undefined; }>>';
-  const _ve3 = "(ReadonlyArray<Readonly<{ id: string; assignments: readonly Readonly<{ dimensionId: string; value: ExperimentScalar; }>[]; }>> | undefined)";
-  const _vp1 = (input, _path, _exceptionable = true) => typeof input["id"] === "string" || _report(_exceptionable, {
-    path: _path + ".id",
-    expected: "string",
-    value: input["id"]
-  });
-  const _ve4 = '(Readonly<{ kind: "bool"; }> | Readonly<{ kind: "choice"; values: readonly ExperimentScalar[]; }> | Readonly<{ kind: "int"; min: number; max: number; }> | Readonly<{ kind: "number"; min: number; max: number; scale?: "linear" | "log" | undefined; }>)';
-  const _vp2 = (input, _path, _exceptionable = true) => typeof input["min"] === "number" || _report(_exceptionable, {
-    path: _path + ".min",
-    expected: "number",
-    value: input["min"]
-  });
-  const _vp3 = (input, _path, _exceptionable = true) => typeof input["max"] === "number" || _report(_exceptionable, {
-    path: _path + ".max",
-    expected: "number",
-    value: input["max"]
-  });
-  const _ve5 = '(Readonly<{ kind: "bool"; }> | Readonly<{ kind: "int"; min: number; max: number; }> | Readonly<{ kind: "number"; min: number; max: number; scale?: "linear" | "log" | undefined; }> | Readonly<{ kind: "choice"; values: readonly ExperimentScalar[]; }>)';
-  const _io0 = (input) => input.schemaVersion === 1 && (typeof input.scenario === "object" && input.scenario !== null && _io1(input.scenario)) && (typeof input.model === "object" && input.model !== null && _io2(input.model)) && (input.strategy === undefined || typeof input.strategy === "object" && input.strategy !== null && _io3(input.strategy)) && _ip0(input) && (input.goal === undefined || typeof input.goal === "object" && input.goal !== null && _io4(input.goal)) && (input.objectives === undefined || Array.isArray(input.objectives) && input.objectives.every((elem) => typeof elem === "object" && elem !== null && _io5(elem))) && (input.constraints === undefined || Array.isArray(input.constraints) && input.constraints.every((elem) => typeof elem === "object" && elem !== null && _io6(elem))) && (Array.isArray(input.dimensions) && input.dimensions.every((elem) => typeof elem === "object" && elem !== null && _io7(elem))) && (input.candidates === undefined || Array.isArray(input.candidates) && input.candidates.every((elem) => typeof elem === "object" && elem !== null && _io12(elem))) && (typeof input.budget === "object" && input.budget !== null && _io14(input.budget)) && (Array.isArray(input.seeds) && input.seeds.every((elem) => typeof elem === "number")) && typeof input.horizonSec === "number" && typeof input.stepSec === "number" && (typeof input.session === "object" && input.session !== null && _io15(input.session));
-  const _io1 = (input) => typeof input.ref === "string" && typeof input.hash === "string";
-  const _io10 = (input) => input.kind === "number" && _ip2(input) && _ip3(input) && (input.scale === undefined || input.scale === "linear" || input.scale === "log");
-  const _io11 = (input) => input.kind === "choice" && (Array.isArray(input.values) && input.values.every((elem) => elem === null || typeof elem === "string" || typeof elem === "number" || typeof elem === "boolean"));
-  const _io12 = (input) => _ip1(input) && (Array.isArray(input.assignments) && input.assignments.every((elem) => typeof elem === "object" && elem !== null && _io13(elem)));
-  const _io13 = (input) => typeof input.dimensionId === "string" && (input.value === null || typeof input.value === "string" || typeof input.value === "number" || typeof input.value === "boolean");
-  const _io14 = (input) => typeof input.candidates === "number" && typeof input.seeds === "number";
-  const _io15 = (input) => typeof input.pattern === "string" && typeof input.days === "number";
-  const _io2 = (input) => _ip1(input) && typeof input.version === "number";
-  const _io3 = (input) => _ip1(input);
-  const _io4 = (input) => typeof input.target === "number";
-  const _io5 = (input) => _ip1(input) && _ip0(input) && (input.sense === "higher" || input.sense === "lower");
-  const _io6 = (input) => _ip1(input) && _ip0(input) && (input.op === "gte" || input.op === "lte") && typeof input.limit === "number";
-  const _io7 = (input) => _ip1(input) && (input.target === "model" || input.target === "session" || input.target === "strategy") && typeof input.path === "string" && (typeof input.space === "object" && input.space !== null && _iu0(input.space)) && (input.baseline === null || typeof input.baseline === "string" || typeof input.baseline === "number" || typeof input.baseline === "boolean") && (input.probes === undefined || Array.isArray(input.probes) && input.probes.every((elem) => elem === null || typeof elem === "string" || typeof elem === "number" || typeof elem === "boolean"));
-  const _io8 = (input) => input.kind === "bool";
-  const _io9 = (input) => input.kind === "int" && _ip2(input) && _ip3(input);
-  const _iu0 = (input) => (() => {
-    if (input.kind === "bool")
-      return _io8(input);
-    else if (input.kind === "int")
-      return _io9(input);
-    else if (input.kind === "number")
-      return _io10(input);
-    else if (input.kind === "choice")
-      return _io11(input);
-    else
-      return false;
-  })();
-  const _vo0 = (input, _path, _exceptionable = true) => [input.schemaVersion === 1 || _report(_exceptionable, {
+  const _ip0 = (input) => input["schemaVersion"] === 1;
+  const _ip1 = (input) => typeof input["scenario"] === "object" && input["scenario"] !== null && _io1(input["scenario"]);
+  const _ip2 = (input) => typeof input["model"] === "object" && input["model"] !== null && _io2(input["model"]);
+  const _ip3 = (input) => input["strategy"] === undefined || typeof input["strategy"] === "object" && input["strategy"] !== null && _io3(input["strategy"]);
+  const _ip4 = (input) => input["metricId"] === "endMoney" || input["metricId"] === "timeToMilestone" || input["metricId"] === "timeToMoney" || input["metricId"] === "varBenefit";
+  const _ip5 = (input) => input["goal"] === undefined || typeof input["goal"] === "object" && input["goal"] !== null && _io4(input["goal"]);
+  const _ip6 = (input) => input["milestoneKey"] === undefined || typeof input["milestoneKey"] === "string";
+  const _ip7 = (input) => input["objectives"] === undefined || Array.isArray(input["objectives"]) && input["objectives"].every((elem) => typeof elem === "object" && elem !== null && _io5(elem));
+  const _ip8 = (input) => input["constraints"] === undefined || Array.isArray(input["constraints"]) && input["constraints"].every((elem) => typeof elem === "object" && elem !== null && _io6(elem));
+  const _ip9 = (input) => Array.isArray(input["dimensions"]) && input["dimensions"].every((elem) => typeof elem === "object" && elem !== null && _io7(elem));
+  const _ip10 = (input) => input["candidates"] === undefined || Array.isArray(input["candidates"]) && input["candidates"].every((elem) => typeof elem === "object" && elem !== null && _io12(elem));
+  const _ip11 = (input) => typeof input["budget"] === "object" && input["budget"] !== null && _io14(input["budget"]);
+  const _ip12 = (input) => Array.isArray(input["seeds"]) && input["seeds"].every((elem) => typeof elem === "number");
+  const _ip13 = (input) => typeof input["horizonSec"] === "number";
+  const _ip14 = (input) => typeof input["stepSec"] === "number";
+  const _ip15 = (input) => typeof input["session"] === "object" && input["session"] !== null && _io15(input["session"]);
+  const _ip16 = (input) => typeof input["id"] === "string";
+  const _ip17 = (input) => typeof input["min"] === "number";
+  const _ip18 = (input) => typeof input["max"] === "number";
+  const _ve0 = "Readonly<{ schemaVersion: 1; scenario: Readonly<{ ref: string; hash: string; }>; model: Readonly<{ id: string; version: number; }>; strategy?: Readonly<{ id: string; }> | undefined; ... 11 more ...; session: Readonly<...>; }>";
+  const _vp0 = (input, _path, _exceptionable = true) => input["schemaVersion"] === 1 || _report(_exceptionable, {
     path: _path + ".schemaVersion",
     expected: "1",
-    value: input.schemaVersion
-  }), (typeof input.scenario === "object" && input.scenario !== null || _report(_exceptionable, {
+    value: input["schemaVersion"]
+  });
+  const _vp1 = (input, _path, _exceptionable = true) => (typeof input["scenario"] === "object" && input["scenario"] !== null || _report(_exceptionable, {
     path: _path + ".scenario",
     expected: "Readonly<{ ref: string; hash: string; }>",
-    value: input.scenario
-  })) && _vo1(input.scenario, _path + ".scenario", _exceptionable) || _report(_exceptionable, {
+    value: input["scenario"]
+  })) && _vo1(input["scenario"], _path + ".scenario", _exceptionable) || _report(_exceptionable, {
     path: _path + ".scenario",
     expected: "Readonly<{ ref: string; hash: string; }>",
-    value: input.scenario
-  }), (typeof input.model === "object" && input.model !== null || _report(_exceptionable, {
+    value: input["scenario"]
+  });
+  const _vp2 = (input, _path, _exceptionable = true) => (typeof input["model"] === "object" && input["model"] !== null || _report(_exceptionable, {
     path: _path + ".model",
     expected: "Readonly<{ id: string; version: number; }>",
-    value: input.model
-  })) && _vo2(input.model, _path + ".model", _exceptionable) || _report(_exceptionable, {
+    value: input["model"]
+  })) && _vo2(input["model"], _path + ".model", _exceptionable) || _report(_exceptionable, {
     path: _path + ".model",
     expected: "Readonly<{ id: string; version: number; }>",
-    value: input.model
-  }), input.strategy === undefined || (typeof input.strategy === "object" && input.strategy !== null || _report(_exceptionable, {
+    value: input["model"]
+  });
+  const _vp3 = (input, _path, _exceptionable = true) => input["strategy"] === undefined || (typeof input["strategy"] === "object" && input["strategy"] !== null || _report(_exceptionable, {
     path: _path + ".strategy",
     expected: "(Readonly<{ id: string; }> | undefined)",
-    value: input.strategy
-  })) && _vo3(input.strategy, _path + ".strategy", _exceptionable) || _report(_exceptionable, {
+    value: input["strategy"]
+  })) && _vo3(input["strategy"], _path + ".strategy", _exceptionable) || _report(_exceptionable, {
     path: _path + ".strategy",
     expected: "(Readonly<{ id: string; }> | undefined)",
-    value: input.strategy
-  }), _vp0(input, _path, _exceptionable), input.goal === undefined || (typeof input.goal === "object" && input.goal !== null || _report(_exceptionable, {
+    value: input["strategy"]
+  });
+  const _vp4 = (input, _path, _exceptionable = true) => input["metricId"] === "endMoney" || input["metricId"] === "timeToMilestone" || input["metricId"] === "timeToMoney" || input["metricId"] === "varBenefit" || _report(_exceptionable, {
+    path: _path + ".metricId",
+    expected: '("endMoney" | "timeToMilestone" | "timeToMoney" | "varBenefit")',
+    value: input["metricId"]
+  });
+  const _vp5 = (input, _path, _exceptionable = true) => input["goal"] === undefined || (typeof input["goal"] === "object" && input["goal"] !== null || _report(_exceptionable, {
     path: _path + ".goal",
     expected: "(Readonly<{ target: number; }> | undefined)",
-    value: input.goal
-  })) && _vo4(input.goal, _path + ".goal", _exceptionable) || _report(_exceptionable, {
+    value: input["goal"]
+  })) && _vo4(input["goal"], _path + ".goal", _exceptionable) || _report(_exceptionable, {
     path: _path + ".goal",
     expected: "(Readonly<{ target: number; }> | undefined)",
-    value: input.goal
-  }), input.objectives === undefined || (Array.isArray(input.objectives) || _report(_exceptionable, {
+    value: input["goal"]
+  });
+  const _vp6 = (input, _path, _exceptionable = true) => input["milestoneKey"] === undefined || typeof input["milestoneKey"] === "string" || _report(_exceptionable, {
+    path: _path + ".milestoneKey",
+    expected: "(string | undefined)",
+    value: input["milestoneKey"]
+  });
+  const _vp7 = (input, _path, _exceptionable = true) => input["objectives"] === undefined || (Array.isArray(input["objectives"]) || _report(_exceptionable, {
     path: _path + ".objectives",
     expected: '(ReadonlyArray<Readonly<{ id: string; metricId: ExperimentMetricId; sense: "higher" | "lower"; }>> | undefined)',
-    value: input.objectives
-  })) && input.objectives.map((elem, _index9) => (typeof elem === "object" && elem !== null || _report(_exceptionable, {
+    value: input["objectives"]
+  })) && input["objectives"].map((elem, _index9) => (typeof elem === "object" && elem !== null || _report(_exceptionable, {
     path: _path + ".objectives[" + _index9 + "]",
     expected: 'Readonly<{ id: string; metricId: ExperimentMetricId; sense: "higher" | "lower"; }>',
     value: elem
@@ -15882,12 +16094,13 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
   })).every((flag) => flag) || _report(_exceptionable, {
     path: _path + ".objectives",
     expected: '(ReadonlyArray<Readonly<{ id: string; metricId: ExperimentMetricId; sense: "higher" | "lower"; }>> | undefined)',
-    value: input.objectives
-  }), input.constraints === undefined || (Array.isArray(input.constraints) || _report(_exceptionable, {
+    value: input["objectives"]
+  });
+  const _vp8 = (input, _path, _exceptionable = true) => input["constraints"] === undefined || (Array.isArray(input["constraints"]) || _report(_exceptionable, {
     path: _path + ".constraints",
     expected: '(ReadonlyArray<Readonly<{ id: string; metricId: ExperimentMetricId; op: "gte" | "lte"; limit: number; }>> | undefined)',
-    value: input.constraints
-  })) && input.constraints.map((elem, _index10) => (typeof elem === "object" && elem !== null || _report(_exceptionable, {
+    value: input["constraints"]
+  })) && input["constraints"].map((elem, _index10) => (typeof elem === "object" && elem !== null || _report(_exceptionable, {
     path: _path + ".constraints[" + _index10 + "]",
     expected: 'Readonly<{ id: string; metricId: ExperimentMetricId; op: "gte" | "lte"; limit: number; }>',
     value: elem
@@ -15898,12 +16111,13 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
   })).every((flag) => flag) || _report(_exceptionable, {
     path: _path + ".constraints",
     expected: '(ReadonlyArray<Readonly<{ id: string; metricId: ExperimentMetricId; op: "gte" | "lte"; limit: number; }>> | undefined)',
-    value: input.constraints
-  }), (Array.isArray(input.dimensions) || _report(_exceptionable, {
+    value: input["constraints"]
+  });
+  const _vp9 = (input, _path, _exceptionable = true) => (Array.isArray(input["dimensions"]) || _report(_exceptionable, {
     path: _path + ".dimensions",
     expected: _ve2,
-    value: input.dimensions
-  })) && input.dimensions.map((elem, _index11) => (typeof elem === "object" && elem !== null || _report(_exceptionable, {
+    value: input["dimensions"]
+  })) && input["dimensions"].map((elem, _index11) => (typeof elem === "object" && elem !== null || _report(_exceptionable, {
     path: _path + ".dimensions[" + _index11 + "]",
     expected: _ve1,
     value: elem
@@ -15914,12 +16128,15 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
   })).every((flag) => flag) || _report(_exceptionable, {
     path: _path + ".dimensions",
     expected: _ve2,
-    value: input.dimensions
-  }), input.candidates === undefined || (Array.isArray(input.candidates) || _report(_exceptionable, {
+    value: input["dimensions"]
+  });
+  const _ve1 = 'Readonly<{ id: string; target: "model" | "session" | "strategy"; path: string; space: ExperimentParamSpace; baseline: ExperimentScalar; probes?: readonly ExperimentScalar[] | undefined; }>';
+  const _ve2 = 'ReadonlyArray<Readonly<{ id: string; target: "model" | "session" | "strategy"; path: string; space: ExperimentParamSpace; baseline: ExperimentScalar; probes?: readonly ExperimentScalar[] | undefined; }>>';
+  const _vp10 = (input, _path, _exceptionable = true) => input["candidates"] === undefined || (Array.isArray(input["candidates"]) || _report(_exceptionable, {
     path: _path + ".candidates",
     expected: _ve3,
-    value: input.candidates
-  })) && input.candidates.map((elem, _index12) => (typeof elem === "object" && elem !== null || _report(_exceptionable, {
+    value: input["candidates"]
+  })) && input["candidates"].map((elem, _index12) => (typeof elem === "object" && elem !== null || _report(_exceptionable, {
     path: _path + ".candidates[" + _index12 + "]",
     expected: "Readonly<{ id: string; assignments: readonly Readonly<{ dimensionId: string; value: ExperimentScalar; }>[]; }>",
     value: elem
@@ -15930,44 +16147,96 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
   })).every((flag) => flag) || _report(_exceptionable, {
     path: _path + ".candidates",
     expected: _ve3,
-    value: input.candidates
-  }), (typeof input.budget === "object" && input.budget !== null || _report(_exceptionable, {
+    value: input["candidates"]
+  });
+  const _ve3 = "(ReadonlyArray<Readonly<{ id: string; assignments: readonly Readonly<{ dimensionId: string; value: ExperimentScalar; }>[]; }>> | undefined)";
+  const _vp11 = (input, _path, _exceptionable = true) => (typeof input["budget"] === "object" && input["budget"] !== null || _report(_exceptionable, {
     path: _path + ".budget",
     expected: "Readonly<{ candidates: number; seeds: number; }>",
-    value: input.budget
-  })) && _vo14(input.budget, _path + ".budget", _exceptionable) || _report(_exceptionable, {
+    value: input["budget"]
+  })) && _vo14(input["budget"], _path + ".budget", _exceptionable) || _report(_exceptionable, {
     path: _path + ".budget",
     expected: "Readonly<{ candidates: number; seeds: number; }>",
-    value: input.budget
-  }), (Array.isArray(input.seeds) || _report(_exceptionable, {
+    value: input["budget"]
+  });
+  const _vp12 = (input, _path, _exceptionable = true) => (Array.isArray(input["seeds"]) || _report(_exceptionable, {
     path: _path + ".seeds",
     expected: "ReadonlyArray<number>",
-    value: input.seeds
-  })) && input.seeds.map((elem, _index13) => typeof elem === "number" || _report(_exceptionable, {
+    value: input["seeds"]
+  })) && input["seeds"].map((elem, _index13) => typeof elem === "number" || _report(_exceptionable, {
     path: _path + ".seeds[" + _index13 + "]",
     expected: "number",
     value: elem
   })).every((flag) => flag) || _report(_exceptionable, {
     path: _path + ".seeds",
     expected: "ReadonlyArray<number>",
-    value: input.seeds
-  }), typeof input.horizonSec === "number" || _report(_exceptionable, {
+    value: input["seeds"]
+  });
+  const _vp13 = (input, _path, _exceptionable = true) => typeof input["horizonSec"] === "number" || _report(_exceptionable, {
     path: _path + ".horizonSec",
     expected: "number",
-    value: input.horizonSec
-  }), typeof input.stepSec === "number" || _report(_exceptionable, {
+    value: input["horizonSec"]
+  });
+  const _vp14 = (input, _path, _exceptionable = true) => typeof input["stepSec"] === "number" || _report(_exceptionable, {
     path: _path + ".stepSec",
     expected: "number",
-    value: input.stepSec
-  }), (typeof input.session === "object" && input.session !== null || _report(_exceptionable, {
+    value: input["stepSec"]
+  });
+  const _vp15 = (input, _path, _exceptionable = true) => (typeof input["session"] === "object" && input["session"] !== null || _report(_exceptionable, {
     path: _path + ".session",
     expected: "Readonly<{ pattern: string; days: number; }>",
-    value: input.session
-  })) && _vo15(input.session, _path + ".session", _exceptionable) || _report(_exceptionable, {
+    value: input["session"]
+  })) && _vo15(input["session"], _path + ".session", _exceptionable) || _report(_exceptionable, {
     path: _path + ".session",
     expected: "Readonly<{ pattern: string; days: number; }>",
-    value: input.session
-  })].every((flag) => flag);
+    value: input["session"]
+  });
+  const _vp16 = (input, _path, _exceptionable = true) => typeof input["id"] === "string" || _report(_exceptionable, {
+    path: _path + ".id",
+    expected: "string",
+    value: input["id"]
+  });
+  const _ve4 = '(Readonly<{ kind: "bool"; }> | Readonly<{ kind: "choice"; values: readonly ExperimentScalar[]; }> | Readonly<{ kind: "int"; min: number; max: number; }> | Readonly<{ kind: "number"; min: number; max: number; scale?: "linear" | "log" | undefined; }>)';
+  const _vp17 = (input, _path, _exceptionable = true) => typeof input["min"] === "number" || _report(_exceptionable, {
+    path: _path + ".min",
+    expected: "number",
+    value: input["min"]
+  });
+  const _vp18 = (input, _path, _exceptionable = true) => typeof input["max"] === "number" || _report(_exceptionable, {
+    path: _path + ".max",
+    expected: "number",
+    value: input["max"]
+  });
+  const _ve5 = '(Readonly<{ kind: "bool"; }> | Readonly<{ kind: "int"; min: number; max: number; }> | Readonly<{ kind: "number"; min: number; max: number; scale?: "linear" | "log" | undefined; }> | Readonly<{ kind: "choice"; values: readonly ExperimentScalar[]; }>)';
+  const _io0 = (input) => _ip0(input) && _ip1(input) && _ip2(input) && _ip3(input) && _ip4(input) && _ip5(input) && _ip6(input) && _ip7(input) && _ip8(input) && _ip9(input) && _ip10(input) && _ip11(input) && _ip12(input) && _ip13(input) && _ip14(input) && _ip15(input);
+  const _io1 = (input) => typeof input.ref === "string" && typeof input.hash === "string";
+  const _io10 = (input) => input.kind === "number" && _ip17(input) && _ip18(input) && (input.scale === undefined || input.scale === "linear" || input.scale === "log");
+  const _io11 = (input) => input.kind === "choice" && (Array.isArray(input.values) && input.values.every((elem) => elem === null || typeof elem === "string" || typeof elem === "number" || typeof elem === "boolean"));
+  const _io12 = (input) => _ip16(input) && (Array.isArray(input.assignments) && input.assignments.every((elem) => typeof elem === "object" && elem !== null && _io13(elem)));
+  const _io13 = (input) => typeof input.dimensionId === "string" && (input.value === null || typeof input.value === "string" || typeof input.value === "number" || typeof input.value === "boolean");
+  const _io14 = (input) => typeof input.candidates === "number" && typeof input.seeds === "number";
+  const _io15 = (input) => typeof input.pattern === "string" && typeof input.days === "number";
+  const _io2 = (input) => _ip16(input) && typeof input.version === "number";
+  const _io3 = (input) => _ip16(input);
+  const _io4 = (input) => typeof input.target === "number";
+  const _io5 = (input) => _ip16(input) && _ip4(input) && (input.sense === "higher" || input.sense === "lower");
+  const _io6 = (input) => _ip16(input) && _ip4(input) && (input.op === "gte" || input.op === "lte") && typeof input.limit === "number";
+  const _io7 = (input) => _ip16(input) && (input.target === "model" || input.target === "session" || input.target === "strategy") && typeof input.path === "string" && (typeof input.space === "object" && input.space !== null && _iu0(input.space)) && (input.baseline === null || typeof input.baseline === "string" || typeof input.baseline === "number" || typeof input.baseline === "boolean") && (input.probes === undefined || Array.isArray(input.probes) && input.probes.every((elem) => elem === null || typeof elem === "string" || typeof elem === "number" || typeof elem === "boolean"));
+  const _io8 = (input) => input.kind === "bool";
+  const _io9 = (input) => input.kind === "int" && _ip17(input) && _ip18(input);
+  const _iu0 = (input) => (() => {
+    if (input.kind === "bool")
+      return _io8(input);
+    else if (input.kind === "int")
+      return _io9(input);
+    else if (input.kind === "number")
+      return _io10(input);
+    else if (input.kind === "choice")
+      return _io11(input);
+    else
+      return false;
+  })();
+  const _vo0 = (input, _path, _exceptionable = true) => [_vp0(input, _path, _exceptionable), _vp1(input, _path, _exceptionable), _vp2(input, _path, _exceptionable), _vp3(input, _path, _exceptionable), _vp4(input, _path, _exceptionable), _vp5(input, _path, _exceptionable), _vp6(input, _path, _exceptionable), _vp7(input, _path, _exceptionable), _vp8(input, _path, _exceptionable), _vp9(input, _path, _exceptionable), _vp10(input, _path, _exceptionable), _vp11(input, _path, _exceptionable), _vp12(input, _path, _exceptionable), _vp13(input, _path, _exceptionable), _vp14(input, _path, _exceptionable), _vp15(input, _path, _exceptionable)].every((flag) => flag);
   const _vo1 = (input, _path, _exceptionable = true) => [typeof input.ref === "string" || _report(_exceptionable, {
     path: _path + ".ref",
     expected: "string",
@@ -15981,7 +16250,7 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     path: _path + ".kind",
     expected: '"number"',
     value: input.kind
-  }), _vp2(input, _path, _exceptionable), _vp3(input, _path, _exceptionable), input.scale === undefined || input.scale === "linear" || input.scale === "log" || _report(_exceptionable, {
+  }), _vp17(input, _path, _exceptionable), _vp18(input, _path, _exceptionable), input.scale === undefined || input.scale === "linear" || input.scale === "log" || _report(_exceptionable, {
     path: _path + ".scale",
     expected: '("linear" | "log" | undefined)',
     value: input.scale
@@ -16003,7 +16272,7 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     expected: "ReadonlyArray<ExperimentScalar>",
     value: input.values
   })].every((flag) => flag);
-  const _vo12 = (input, _path, _exceptionable = true) => [_vp1(input, _path, _exceptionable), (Array.isArray(input.assignments) || _report(_exceptionable, {
+  const _vo12 = (input, _path, _exceptionable = true) => [_vp16(input, _path, _exceptionable), (Array.isArray(input.assignments) || _report(_exceptionable, {
     path: _path + ".assignments",
     expected: "ReadonlyArray<Readonly<{ dimensionId: string; value: ExperimentScalar; }>>",
     value: input.assignments
@@ -16047,23 +16316,23 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     expected: "number",
     value: input.days
   })].every((flag) => flag);
-  const _vo2 = (input, _path, _exceptionable = true) => [_vp1(input, _path, _exceptionable), typeof input.version === "number" || _report(_exceptionable, {
+  const _vo2 = (input, _path, _exceptionable = true) => [_vp16(input, _path, _exceptionable), typeof input.version === "number" || _report(_exceptionable, {
     path: _path + ".version",
     expected: "number",
     value: input.version
   })].every((flag) => flag);
-  const _vo3 = (input, _path, _exceptionable = true) => [_vp1(input, _path, _exceptionable)].every((flag) => flag);
+  const _vo3 = (input, _path, _exceptionable = true) => [_vp16(input, _path, _exceptionable)].every((flag) => flag);
   const _vo4 = (input, _path, _exceptionable = true) => [typeof input.target === "number" || _report(_exceptionable, {
     path: _path + ".target",
     expected: "number",
     value: input.target
   })].every((flag) => flag);
-  const _vo5 = (input, _path, _exceptionable = true) => [_vp1(input, _path, _exceptionable), _vp0(input, _path, _exceptionable), input.sense === "higher" || input.sense === "lower" || _report(_exceptionable, {
+  const _vo5 = (input, _path, _exceptionable = true) => [_vp16(input, _path, _exceptionable), _vp4(input, _path, _exceptionable), input.sense === "higher" || input.sense === "lower" || _report(_exceptionable, {
     path: _path + ".sense",
     expected: '("higher" | "lower")',
     value: input.sense
   })].every((flag) => flag);
-  const _vo6 = (input, _path, _exceptionable = true) => [_vp1(input, _path, _exceptionable), _vp0(input, _path, _exceptionable), input.op === "gte" || input.op === "lte" || _report(_exceptionable, {
+  const _vo6 = (input, _path, _exceptionable = true) => [_vp16(input, _path, _exceptionable), _vp4(input, _path, _exceptionable), input.op === "gte" || input.op === "lte" || _report(_exceptionable, {
     path: _path + ".op",
     expected: '("gte" | "lte")',
     value: input.op
@@ -16072,7 +16341,7 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     expected: "number",
     value: input.limit
   })].every((flag) => flag);
-  const _vo7 = (input, _path, _exceptionable = true) => [_vp1(input, _path, _exceptionable), input.target === "model" || input.target === "session" || input.target === "strategy" || _report(_exceptionable, {
+  const _vo7 = (input, _path, _exceptionable = true) => [_vp16(input, _path, _exceptionable), input.target === "model" || input.target === "session" || input.target === "strategy" || _report(_exceptionable, {
     path: _path + ".target",
     expected: '("model" | "session" | "strategy")',
     value: input.target
@@ -16114,7 +16383,7 @@ var EXPERIMENT_ALGORITHM_VERSION = "experiment-oat-v1", EXPERIMENT_ESTIMATOR_VER
     path: _path + ".kind",
     expected: '"int"',
     value: input.kind
-  }), _vp2(input, _path, _exceptionable), _vp3(input, _path, _exceptionable)].every((flag) => flag);
+  }), _vp17(input, _path, _exceptionable), _vp18(input, _path, _exceptionable)].every((flag) => flag);
   const _vu0 = (input, _path, _exceptionable = true) => (() => {
     if (input.kind === "bool")
       return _vo8(input, _path, _exceptionable);
@@ -18414,7 +18683,7 @@ var init_checks3 = __esm(() => {
   FAIL_ON = ["error", "warn", "inconclusive", "unsupported"];
 });
 
-// ../../node_modules/.bun/typia@15.1.0+367f7514c87f1df1/node_modules/typia/lib/internal/_accessExpressionAsString.mjs
+// ../../node_modules/.bun/typia@15.2.2+38c91d72aa8392f2/node_modules/typia/lib/internal/_accessExpressionAsString.mjs
 var _accessExpressionAsString = (str) => variable(str) ? `.${str}` : `[${JSON.stringify(str)}]`, variable = (str) => reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str), reserved = (str) => RESERVED.has(str), RESERVED;
 var init__accessExpressionAsString = __esm(() => {
   RESERVED = /* @__PURE__ */ new Set([
@@ -18478,6 +18747,9 @@ function nonfiniteThresholds(rubric) {
     if (rule.upperThreshold !== null && !Number.isFinite(rule.upperThreshold)) {
       issues.push(`$input.rules[${index}].upperThreshold finite number or null`);
     }
+    if (rule.metricVersion !== undefined && rule.metricVersion !== null && !Number.isFinite(rule.metricVersion)) {
+      issues.push(`$input.rules[${index}].metricVersion finite number or null`);
+    }
   });
   return issues;
 }
@@ -18503,8 +18775,16 @@ function evaluateGroups(failOn, groups, checks) {
   const pass = reports.every((report) => report.pass);
   return { ...first, results, pass, exitCode: pass ? 0 : 2 };
 }
-function findReadings(artifact, metricId) {
-  return artifact.metrics.filter((reading) => reading.metricId === metricId);
+function ruleReadings(artifact, rule) {
+  const pinned = rule.metricVersion ?? null;
+  return artifact.metrics.filter((reading) => reading.metricId === rule.metricId && (pinned === null || reading.metricVersion === pinned));
+}
+function metricVersionRef(version) {
+  return `metric-version:${version}`;
+}
+function ruleRefLabel(rule) {
+  const pinned = rule.metricVersion ?? null;
+  return pinned === null ? `metric:${rule.metricId}` : `metric:${rule.metricId} ${metricVersionRef(pinned)}`;
 }
 function isUnavailable(reading) {
   return reading.reading === "unavailable" || reading.status !== "ok";
@@ -18671,27 +18951,40 @@ function judgeArtifact(artifact, rubric) {
   const issues = [];
   const groups = new Map;
   const estimatedObservations = [];
+  const estimatedReadings = new Set;
   const prepared = [];
   for (const rule of rubric.rules) {
-    const readings = findReadings(artifact, rule.metricId);
+    const label = ruleRefLabel(rule);
+    const readings = ruleReadings(artifact, rule);
     const reading = readings[0];
     if (!reading) {
-      issues.push(`missing evidenceRef metric:${rule.metricId}`);
+      const others = artifact.metrics.filter((item) => item.metricId === rule.metricId).map((item) => metricVersionRef(item.metricVersion));
+      issues.push(others.length > 0 ? `missing evidenceRef ${label} (artifact has ${others.join(", ")})` : `missing evidenceRef ${label}`);
       continue;
     }
     if (readings.length > 1) {
-      issues.push(`ambiguous evidenceRef metric:${rule.metricId} matches ${readings.length} readings`);
+      issues.push(`ambiguous evidenceRef ${label} matches ${readings.length} readings`);
       continue;
     }
     const mapped = toObservation(artifact, reading, rule);
-    const key = JSON.stringify([reading.metricId, mapped.observation.identity.method, mapped.observation.identity.unit]);
+    const key = JSON.stringify([
+      reading.metricId,
+      reading.metricVersion,
+      mapped.observation.identity.method,
+      mapped.observation.identity.unit
+    ]);
     const group = groups.get(key) ?? { observation: mapped.observation, indices: [] };
     group.indices.push(prepared.length);
     groups.set(key, group);
-    if (mapped.estimated && !estimatedObservations.some((item) => item.metricId === reading.metricId)) {
+    if (mapped.estimated && !estimatedReadings.has(reading)) {
+      estimatedReadings.add(reading);
       estimatedObservations.push(mapped.estimated);
     }
-    prepared.push({ rule, estimated: mapped.estimated, ref: `metric:${rule.metricId}` });
+    prepared.push({
+      rule,
+      estimated: mapped.estimated,
+      refs: [`metric:${rule.metricId}`, metricVersionRef(reading.metricVersion)]
+    });
   }
   if (issues.length > 0)
     return { ok: false, issues };
@@ -18704,7 +18997,7 @@ function judgeArtifact(artifact, rubric) {
       id: item.rule.id,
       category: outcome.category,
       severity: outcome.severity,
-      evidenceRefs: [item.ref],
+      evidenceRefs: item.refs,
       assumptionRefs,
       recommendationId: outcome.recommendationId,
       status: outcome.status,
@@ -18728,9 +19021,9 @@ function judgeArtifact(artifact, rubric) {
   return { ok: true, report };
 }
 var JUDGE_ALGORITHM_VERSION = "judge-rules-1", validateRubricValidator, validateRubric = (input) => (validateRubricValidator ??= (() => {
-  const _ve0 = 'Readonly<{ schemaVersion: 1; contract: "idlekit.judge.rubric.v1"; rubricVersion: string; failOn: readonly FailOnToken[]; rules: readonly Readonly<{ id: string; metricId: string; operator: CheckOperator; ... 13 more ...; recommendationId: RecommendationId; }>[]; }>';
-  const _ve1 = "Readonly<{ id: string; metricId: string; operator: CheckOperator; threshold: number; upperThreshold: number | null; unit: string; severity: CheckSeverity; missingPolicy: MissingPolicy; ... 8 more ...; recommendationId: RecommendationId; }>";
-  const _ve2 = "ReadonlyArray<Readonly<{ id: string; metricId: string; operator: CheckOperator; threshold: number; upperThreshold: number | null; unit: string; severity: CheckSeverity; missingPolicy: MissingPolicy; ... 8 more ...; recommendationId: RecommendationId; }>>";
+  const _ve0 = 'Readonly<{ schemaVersion: 1; contract: "idlekit.judge.rubric.v1"; rubricVersion: string; failOn: readonly FailOnToken[]; rules: readonly Readonly<{ id: string; metricId: string; metricVersion?: number | null | undefined; ... 14 more ...; recommendationId: RecommendationId; }>[]; }>';
+  const _ve1 = "Readonly<{ id: string; metricId: string; metricVersion?: number | null | undefined; operator: CheckOperator; threshold: number; upperThreshold: number | null; unit: string; severity: CheckSeverity; ... 9 more ...; recommendationId: RecommendationId; }>";
+  const _ve2 = "ReadonlyArray<Readonly<{ id: string; metricId: string; metricVersion?: number | null | undefined; operator: CheckOperator; threshold: number; upperThreshold: number | null; unit: string; severity: CheckSeverity; ... 9 more ...; recommendationId: RecommendationId; }>>";
   const _ve3 = '("rec.metric.estimate-not-measured" | "rec.metric.identity-mismatch" | "rec.metric.insufficient" | "rec.metric.outside-threshold" | "rec.metric.unsupported" | "rec.metric.within-threshold")';
   const _io0 = (input, _exceptionable = true) => input.schemaVersion === 1 && input.contract === "idlekit.judge.rubric.v1" && typeof input.rubricVersion === "string" && (Array.isArray(input.failOn) && input.failOn.every((elem, _index1) => elem === "error" || elem === "inconclusive" || elem === "unsupported" || elem === "warn")) && (Array.isArray(input.rules) && input.rules.every((elem, _index2) => typeof elem === "object" && elem !== null && _io1(elem, _exceptionable))) && (Object.keys(input).length === 5 || Object.keys(input).every((key) => {
     if (["schemaVersion", "contract", "rubricVersion", "failOn", "rules"].some((prop) => key === prop))
@@ -18740,8 +19033,8 @@ var JUDGE_ALGORITHM_VERSION = "judge-rules-1", validateRubricValidator, validate
       return true;
     return false;
   }));
-  const _io1 = (input, _exceptionable = true) => typeof input.id === "string" && typeof input.metricId === "string" && (input.operator === "between" || input.operator === "eq" || input.operator === "gt" || input.operator === "gte" || input.operator === "lt" || input.operator === "lte") && typeof input.threshold === "number" && (input.upperThreshold === null || typeof input.upperThreshold === "number") && typeof input.unit === "string" && (input.severity === "error" || input.severity === "warn") && (input.missingPolicy === "fail" || input.missingPolicy === "inconclusive" || input.missingPolicy === "unsupported") && typeof input.definition === "string" && typeof input.method === "string" && (input.scenarioVersion === null || typeof input.scenarioVersion === "string") && (input.specVersion === null || typeof input.specVersion === "string") && (input.engineId === null || typeof input.engineId === "string") && (input.pluginVersion === null || typeof input.pluginVersion === "string") && (input.seed === null || typeof input.seed === "string") && (input.algorithmVersion === null || typeof input.algorithmVersion === "string") && (input.recommendationId === "rec.metric.estimate-not-measured" || input.recommendationId === "rec.metric.identity-mismatch" || input.recommendationId === "rec.metric.insufficient" || input.recommendationId === "rec.metric.outside-threshold" || input.recommendationId === "rec.metric.unsupported" || input.recommendationId === "rec.metric.within-threshold") && (Object.keys(input).length === 17 || Object.keys(input).every((key) => {
-    if (["id", "metricId", "operator", "threshold", "upperThreshold", "unit", "severity", "missingPolicy", "definition", "method", "scenarioVersion", "specVersion", "engineId", "pluginVersion", "seed", "algorithmVersion", "recommendationId"].some((prop) => key === prop))
+  const _io1 = (input, _exceptionable = true) => typeof input.id === "string" && typeof input.metricId === "string" && (input.metricVersion === null || input.metricVersion === undefined || typeof input.metricVersion === "number") && (input.operator === "between" || input.operator === "eq" || input.operator === "gt" || input.operator === "gte" || input.operator === "lt" || input.operator === "lte") && typeof input.threshold === "number" && (input.upperThreshold === null || typeof input.upperThreshold === "number") && typeof input.unit === "string" && (input.severity === "error" || input.severity === "warn") && (input.missingPolicy === "fail" || input.missingPolicy === "inconclusive" || input.missingPolicy === "unsupported") && typeof input.definition === "string" && typeof input.method === "string" && (input.scenarioVersion === null || typeof input.scenarioVersion === "string") && (input.specVersion === null || typeof input.specVersion === "string") && (input.engineId === null || typeof input.engineId === "string") && (input.pluginVersion === null || typeof input.pluginVersion === "string") && (input.seed === null || typeof input.seed === "string") && (input.algorithmVersion === null || typeof input.algorithmVersion === "string") && (input.recommendationId === "rec.metric.estimate-not-measured" || input.recommendationId === "rec.metric.identity-mismatch" || input.recommendationId === "rec.metric.insufficient" || input.recommendationId === "rec.metric.outside-threshold" || input.recommendationId === "rec.metric.unsupported" || input.recommendationId === "rec.metric.within-threshold") && (Object.keys(input).length === 17 || Object.keys(input).every((key) => {
+    if (["id", "metricId", "metricVersion", "operator", "threshold", "upperThreshold", "unit", "severity", "missingPolicy", "definition", "method", "scenarioVersion", "specVersion", "engineId", "pluginVersion", "seed", "algorithmVersion", "recommendationId"].some((prop) => key === prop))
       return true;
     const value = input[key];
     if (value === undefined)
@@ -18814,6 +19107,10 @@ var JUDGE_ALGORITHM_VERSION = "judge-rules-1", validateRubricValidator, validate
     path: _path + ".metricId",
     expected: "string",
     value: input.metricId
+  }), input.metricVersion === null || input.metricVersion === undefined || typeof input.metricVersion === "number" || _report(_exceptionable, {
+    path: _path + ".metricVersion",
+    expected: "(null | number | undefined)",
+    value: input.metricVersion
   }), input.operator === "between" || input.operator === "eq" || input.operator === "gt" || input.operator === "gte" || input.operator === "lt" || input.operator === "lte" || _report(_exceptionable, {
     path: _path + ".operator",
     expected: '("between" | "eq" | "gt" | "gte" | "lt" | "lte")',
@@ -18875,7 +19172,7 @@ var JUDGE_ALGORITHM_VERSION = "judge-rules-1", validateRubricValidator, validate
     expected: _ve3,
     value: input.recommendationId
   }), Object.keys(input).length === 17 || (_exceptionable === false || Object.keys(input).map((key) => {
-    if (["id", "metricId", "operator", "threshold", "upperThreshold", "unit", "severity", "missingPolicy", "definition", "method", "scenarioVersion", "specVersion", "engineId", "pluginVersion", "seed", "algorithmVersion", "recommendationId"].some((prop) => key === prop))
+    if (["id", "metricId", "metricVersion", "operator", "threshold", "upperThreshold", "unit", "severity", "missingPolicy", "definition", "method", "scenarioVersion", "specVersion", "engineId", "pluginVersion", "seed", "algorithmVersion", "recommendationId"].some((prop) => key === prop))
       return true;
     const value = input[key];
     if (value === undefined)
@@ -18961,7 +19258,7 @@ var init_judge = __esm(() => {
 // ../core/dist/sim/analysis/flow.js
 var init_flow = () => {};
 
-// ../../node_modules/.bun/typia@15.1.0+367f7514c87f1df1/node_modules/typia/lib/internal/_isTypeUint32.mjs
+// ../../node_modules/.bun/typia@15.2.2+38c91d72aa8392f2/node_modules/typia/lib/internal/_isTypeUint32.mjs
 var _isTypeUint32 = (value) => Math.floor(value) === value && MINIMUM <= value && value <= MAXIMUM, MINIMUM = 0, MAXIMUM;
 var init__isTypeUint32 = __esm(() => {
   MAXIMUM = 2 ** 32 - 1;
@@ -19353,32 +19650,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":
@@ -19414,9 +19725,21 @@ function compareScenarios(args) {
   }
   const measuredA = measuredScore(args.measured?.a, args.metric);
   const measuredB = measuredScore(args.measured?.b, args.metric);
+  for (const value of [measuredA, measuredB]) {
+    if (value !== undefined && !Number.isFinite(value)) {
+      throw new RangeError(`Measured ${args.metric} comparison requires finite values`);
+    }
+  }
   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 {
@@ -19526,12 +19849,12 @@ function estimateLtvPerUser(args) {
   const fullDays = Math.floor(Math.max(0, horizonDays));
   const remainder = Math.max(0, horizonDays - fullDays);
   let gross = 0;
-  for (let day = 1;day <= fullDays; day++) {
+  for (let day = 0;day < fullDays; day++) {
     const active = retentionAtDay(config.retention, day);
     gross += active * (payerConversion * arppuDaily + adArpDau);
   }
   if (remainder > 0) {
-    const active = retentionAtDay(config.retention, fullDays + 1);
+    const active = retentionAtDay(config.retention, fullDays);
     gross += remainder * active * (payerConversion * arppuDaily + adArpDau);
   }
   const net = gross * (1 - config.revenue.platformFeeRate) * config.revenue.grossMarginRate;
@@ -19653,10 +19976,11 @@ function applyLogNormalShock(mean, sigma, z) {
 }
 function makeUncertainConfig(base, rng) {
   const shock = sampleCorrelatedNormals(rng, base.uncertainty.correlation);
-  const d1 = clamp013(applyLogNormalShock(base.retention.d1, base.uncertainty.sigma.retention, shock.retention));
-  const d7 = Math.min(d1, clamp013(applyLogNormalShock(base.retention.d7, base.uncertainty.sigma.retention, shock.retention)));
-  const d30 = Math.min(d7, clamp013(applyLogNormalShock(base.retention.d30, base.uncertainty.sigma.retention, shock.retention)));
-  const d90 = Math.min(d30, clamp013(applyLogNormalShock(base.retention.d90, base.uncertainty.sigma.retention, shock.retention)));
+  const retention = (anchor) => clamp013(applyLogNormalShock(anchor, base.uncertainty.sigma.retention, shock.retention));
+  const d1 = retention(base.retention.d1);
+  const d7 = retention(base.retention.d7);
+  const d30 = retention(base.retention.d30);
+  const d90 = retention(base.retention.d90);
   return {
     ...base,
     retention: {
@@ -19680,6 +20004,23 @@ function quantileFromSorted(sorted, q) {
   const idx = Math.max(0, Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * q)));
   return sorted[idx] ?? 0;
 }
+function quantileKey(q) {
+  const [mantissa = "0", exponent = "0"] = String(q).split("e");
+  const [whole = "0", fraction = ""] = mantissa.split(".");
+  const digits = whole + fraction;
+  const point = whole.length + Number(exponent) + 2;
+  const shifted = point <= 0 ? `0.${"0".repeat(-point)}${digits}` : point >= digits.length ? digits + "0".repeat(point - digits.length) : `${digits.slice(0, point)}.${digits.slice(point)}`;
+  const [int = "0", frac = ""] = shifted.split(".");
+  let start = 0;
+  while (start < int.length - 1 && int[start] === "0")
+    start++;
+  let end = frac.length;
+  while (end > 0 && frac[end - 1] === "0")
+    end--;
+  const trimmedInt = int.slice(start);
+  const trimmedFrac = frac.slice(0, end);
+  return `q${trimmedFrac ? `${trimmedInt}.${trimmedFrac}` : trimmedInt}`;
+}
 function estimateLtvDistribution(args) {
   const rng = mulberry32(args.seed);
   const grossSamples = [];
@@ -19701,7 +20042,7 @@ function estimateLtvDistribution(args) {
   const sortedLtv = [...ltvSamples].sort((a, b) => a - b);
   const byQuantile = {};
   for (const q of args.quantiles) {
-    byQuantile[`q${Math.round(q * 100)}`] = quantileFromSorted(sortedLtv, q);
+    byQuantile[quantileKey(q)] = quantileFromSorted(sortedLtv, q);
   }
   return {
     mean: {
@@ -19736,8 +20077,7 @@ function assertQuantileValues(quantiles) {
       throw new RangeError("quantiles must be nonempty and in 0..1");
   }
 }
-function assertConfig(config) {
-  const { retention, ...other } = config;
+function assertRetention(retention) {
   for (const day of ["d1", "d7", "d30", "d90"]) {
     if (!Number.isFinite(retention[day]) || retention[day] < 0 || retention[day] > 1) {
       throw new RangeError(`retention.${day} must be finite and in 0..1`);
@@ -19746,6 +20086,10 @@ function assertConfig(config) {
   if (!Number.isFinite(retention.longTailDailyDecay) || retention.longTailDailyDecay < 0) {
     throw new RangeError("retention.longTailDailyDecay must be finite and >= 0");
   }
+}
+function assertConfig(config) {
+  const { retention, ...other } = config;
+  assertRetention(retention);
   const { quantiles, ...uncertainty } = other.uncertainty;
   assertQuantileValues(quantiles);
   assertMonetization({ ...other, uncertainty });
@@ -19756,6 +20100,14 @@ function deriveMonetizationConfig2(scenario) {
   assertConfig(config);
   return config;
 }
+function progressionFactor2(startWorthLog10, endWorthLog10, span) {
+  if (Number.isNaN(startWorthLog10) || Number.isNaN(endWorthLog10)) {
+    throw new RangeError("worth logs must not be NaN");
+  }
+  if (!Number.isFinite(span) || span <= 0)
+    throw new RangeError("span must be finite and > 0");
+  return progressionFactor(startWorthLog10, endWorthLog10, span);
+}
 function assertPoint(args) {
   assertConfig(args.config);
   if (!Number.isFinite(args.horizonDays) || args.horizonDays < 0 || args.horizonDays > 36500) {
@@ -19776,18 +20128,24 @@ function estimateLtvPerUser2(args) {
 }
 function estimateLtvDistribution2(args) {
   assertPoint(args);
-  if (!Number.isSafeInteger(args.draws) || args.draws < 1 || args.draws > 1e5 || args.draws * Math.max(1, Math.ceil(args.horizonDays)) > 1e7) {
+  const draws = args.draws ?? args.config.uncertainty.draws;
+  const quantiles = args.quantiles ?? args.config.uncertainty.quantiles;
+  const seed = args.seed ?? args.config.uncertainty.seed;
+  if (!Number.isSafeInteger(draws) || draws < 1 || draws > 1e5 || draws * Math.max(1, Math.ceil(args.horizonDays)) > 1e7) {
     throw new RangeError("draws must be 1..100000 and draws \xD7 ceil(horizonDays) at most 10000000");
   }
-  if (!Number.isFinite(args.seed))
-    throw new RangeError("seed must be finite");
-  if (args.quantiles.length > 101)
-    throw new RangeError("quantiles exceed the 101 distinct percent keys");
-  assertQuantileValues(args.quantiles);
-  if (new Set(args.quantiles.map((q) => Math.round(q * 100))).size !== args.quantiles.length) {
-    throw new RangeError("quantiles must be nonempty, in 0..1 and have distinct rounded percent keys");
+  if (seed === undefined)
+    throw new RangeError("seed is required: pass seed or set config.uncertainty.seed");
+  if (!Number.isInteger(seed) || seed < 0 || seed > 4294967295) {
+    throw new RangeError("seed must be an integer in 0..4294967295");
+  }
+  if (quantiles.length > 101)
+    throw new RangeError("quantiles exceed 101 entries");
+  assertQuantileValues(quantiles);
+  if (new Set(quantiles.map(quantileKey)).size !== quantiles.length) {
+    throw new RangeError("quantiles must be distinct values in 0..1");
   }
-  const result = estimateLtvDistribution(args);
+  const result = estimateLtvDistribution({ ...args, draws, quantiles, seed });
   finiteResult(result.mean);
   finiteResult(result.quantiles);
   return result;
@@ -19797,6 +20155,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}. A complete scenario retention curve must satisfy d1 >= d7 >= d30 >= d90, and the LTV model would interpolate a rise as given; 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,15 +20366,18 @@ var init_dist2 = __esm(() => {
   init_flow();
   init_jevAdvisory();
   init_public();
+  init_cohort();
 });
 
 // src/runtime/bun.ts
 var {$ } = globalThis.Bun;
 import { dirname } from "path";
 async function readTextFile(path) {
+  recordInputRead(path);
   return Bun.file(path).text();
 }
 async function readJsonFile(path) {
+  recordInputRead(path);
   return Bun.file(path).json();
 }
 async function writeTextFile(path, body) {
@@ -19921,6 +20427,7 @@ function runText(args, opts) {
 var MAX_CAPTURE_BYTES;
 var init_bun = __esm(() => {
   init_errors3();
+  init_invocation();
   MAX_CAPTURE_BYTES = 8 * 1024 * 1024;
 });
 
@@ -19928,7 +20435,7 @@ var init_bun = __esm(() => {
 var require_package = __commonJS(function(exports, module) {
   module.exports = {
     name: "@idlekit/cli",
-    version: "0.5.1",
+    version: "0.7.0",
     description: "Bun-first idk CLI for idle game scenario validation, simulation, tuning, and reporting.",
     license: "MIT",
     type: "module",
@@ -19981,7 +20488,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.7.0",
       ajv: "^8.20.0",
       gunshi: "0.37.3",
       "proper-lockfile": "4.1.2",
@@ -19996,7 +20503,7 @@ var require_package = __commonJS(function(exports, module) {
 
 // src/runtime/selfCli.ts
 import { existsSync } from "fs";
-import { dirname as dirname3, resolve as resolve2 } from "path";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 function currentEntry() {
   return Bun.main;
 }
@@ -20013,11 +20520,11 @@ function cliPackageRoot(entry = currentEntry()) {
   if (isNativeEntry(entry))
     return process.cwd();
   if (isBundledCliProcess(entry))
-    return resolve2(dirname3(entry), "..");
-  return resolve2(import.meta.dir, "../..");
+    return resolve3(dirname3(entry), "..");
+  return resolve3(import.meta.dir, "../..");
 }
 function bundledCliConfig(entry) {
-  const config = resolve2(dirname3(entry), "../../../tools/bundled-cli-bunfig.toml");
+  const config = resolve3(dirname3(entry), "../../../tools/bundled-cli-bunfig.toml");
   if (!existsSync(config))
     return;
   return config;
@@ -20032,7 +20539,7 @@ function selfCliCommand(args, entry = currentEntry()) {
       return [bun, `--config=${config}`, entry, ...args];
     return [bun, entry, ...args];
   }
-  const bunfigApplies = resolve2(process.cwd()) === CLI_ROOT;
+  const bunfigApplies = resolve3(process.cwd()) === CLI_ROOT;
   if (entry.endsWith(".ts") && !bunfigApplies) {
     return [bun, "--preload", "@ttsc/unplugin/bun-register", entry, ...args];
   }
@@ -20054,16 +20561,16 @@ function runSelfCli(args) {
 }
 var CLI_ROOT, MAX_CAPTURE_BYTES2;
 var init_selfCli = __esm(() => {
-  CLI_ROOT = resolve2(import.meta.dir, "../..");
+  CLI_ROOT = resolve3(import.meta.dir, "../..");
   MAX_CAPTURE_BYTES2 = 8 * 1024 * 1024;
 });
 
 // src/io/outputMeta.ts
-import { dirname as dirname4, resolve as resolve3 } from "path";
+import { dirname as dirname4, resolve as resolve4 } from "path";
 function repoRoot() {
   if (isBundledCliProcess())
-    return resolve3(dirname4(Bun.main), "../..");
-  return resolve3(import.meta.dir, "../../..");
+    return resolve4(dirname4(Bun.main), "../..");
+  return resolve4(import.meta.dir, "../../..");
 }
 function stableStringify(value) {
   if (value === null || typeof value !== "object") {
@@ -28787,7 +29294,7 @@ var init_jev_schema = __esm(() => {
 
 // src/lib/evaluation/providers/jev.ts
 import { closeSync, lstatSync, mkdirSync, openSync, readFileSync, readlinkSync, realpathSync as realpathSync2, renameSync, unlinkSync, writeFileSync } from "fs";
-import { basename as basename2, dirname as dirname5, resolve as resolve6 } from "path";
+import { basename as basename2, dirname as dirname5, resolve as resolve7 } from "path";
 function pathEnd(value, start, run) {
   const end = start + run.length;
   if (FILE_COMPONENT.test(run))
@@ -28844,19 +29351,18 @@ function isSafeJevReport(report, keyMaterial) {
   return JSON.stringify(redact(report, keyMaterial)) === JSON.stringify(report);
 }
 function projectJevState(artifact, rubric, keyMaterial) {
-  const referenced = new Set(rubric.rules.map((rule) => rule.metricId));
-  const seenMetricIds = new Set;
-  const firstReadings = artifact.metrics.filter((metric) => {
-    if (!referenced.has(metric.metricId) || seenMetricIds.has(metric.metricId))
-      return false;
-    seenMetricIds.add(metric.metricId);
-    return true;
-  });
+  const rulesByReading = new Map;
+  for (const rule of rubric.rules) {
+    const selected = ruleReadings(artifact, rule)[0];
+    if (selected)
+      rulesByReading.set(selected, [...rulesByReading.get(selected) ?? [], rule]);
+  }
+  const firstReadings = artifact.metrics.filter((metric) => rulesByReading.has(metric));
   const coverage = artifact.observationCoverage;
   const judged = judgeArtifact(artifact, rubric);
   const verdicts = new Map(judged.ok ? judged.report.numerical.results.map((result) => [result.id, result.verdict]) : []);
   const withheld = coverage === "incomplete" || coverage === "unknown" || coverage === "disabled" || artifact.capabilities.metrics !== "statically-known";
-  const metrics = firstReadings.flatMap((metric) => rubric.rules.filter((rule) => rule.metricId === metric.metricId).map((rule) => {
+  const metrics = firstReadings.flatMap((metric) => (rulesByReading.get(metric) ?? []).map((rule) => {
     const { observation } = toObservation(artifact, metric, rule);
     return {
       ...observation.identity,
@@ -29092,14 +29598,14 @@ function cacheTarget(path, depth = 0) {
   } catch {
     try {
       if (lstatSync(path).isSymbolicLink())
-        return cacheTarget(resolve6(dirname5(path), readlinkSync(path)), depth + 1);
+        return cacheTarget(resolve7(dirname5(path), readlinkSync(path)), depth + 1);
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
     }
-    const absolute = resolve6(path);
+    const absolute = resolve7(path);
     const parent = dirname5(absolute);
-    return parent === absolute ? absolute : resolve6(cacheTarget(parent, depth), basename2(absolute));
+    return parent === absolute ? absolute : resolve7(cacheTarget(parent, depth), basename2(absolute));
   }
 }
 async function writeCache(requestedPath, entry) {
@@ -34053,6 +34559,7 @@ function getTerminalInfo() {
 }
 
 // src/runtime/command.ts
+init_invocation();
 function option(schema, metadata = {}) {
   return { schema, ...metadata };
 }
@@ -34173,14 +34680,15 @@ async function createCLI(config) {
             throw usageError(`Invalid --${key}: ${parsed.error.message}`);
           flags[key] = parsed.data;
         }
-        await selected.handler({
+        const positional = [...ctx.positionals.slice(ctx.commandPath.length), ...ctx.rest];
+        await runWithInvocation({ positional, flags }, () => selected.handler({
           flags,
-          positional: [...ctx.positionals.slice(ctx.commandPath.length), ...ctx.rest],
+          positional,
           terminal: getTerminalInfo(),
           prompt,
           cwd: process.cwd(),
           runtime: { args: [...ctx._] }
-        });
+        }));
       }
     });
   };
@@ -34251,8 +34759,9 @@ init_zod();
 // src/plugin/load.ts
 init_dist2();
 init_bun();
+init_invocation();
 import { realpathSync } from "fs";
-import { dirname as dirname2, extname, isAbsolute, relative, resolve, sep } from "path";
+import { dirname as dirname2, extname, isAbsolute, relative, resolve as resolve2, sep } from "path";
 import { fileURLToPath } from "url";
 
 // src/lib/designObjectives.ts
@@ -34264,7 +34773,7 @@ init_dist2();
 function quantile(values, q) {
   return quantileInclusiveFloor(values, q) ?? undefined;
 }
-function quantileKey(quantiles, q) {
+function quantileKey2(quantiles, q) {
   const percent = Math.round(q * 100);
   const legacy = `q${percent}`;
   const collided = quantiles.some((other) => other !== q && `q${Math.round(other * 100)}` === legacy);
@@ -34277,7 +34786,7 @@ function summarizeNumeric(values, quantiles) {
     return null;
   return {
     mean: values.reduce((sum, value) => sum + value, 0) / values.length,
-    quantiles: Object.fromEntries(quantiles.map((q) => [quantileKey(quantiles, q), quantileInclusiveFloor(values, q) ?? Number.NaN]))
+    quantiles: Object.fromEntries(quantiles.map((q) => [quantileKey2(quantiles, q), quantileInclusiveFloor(values, q) ?? Number.NaN]))
   };
 }
 function resolveSessionPatternSpec(args) {
@@ -34918,10 +35427,11 @@ init_errors3();
 function ownedCount(state) {
   return Number(state?.vars?.owned ?? 0);
 }
+var NUMBER_ONLY_COMMANDS = ["report", "analyze", "eta", "growth", "prestige-cycle"];
 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: `${NUMBER_ONLY_COMMANDS.join(", ")} run only the number engine; reduce their inputs.`
     });
   }
   return value;
@@ -35157,7 +35667,7 @@ function normalizeSha256(input) {
   return x;
 }
 function parsePluginRoots(input) {
-  const list = parseCommaSeparated(input).map((x) => resolve(x));
+  const list = parseCommaSeparated(input).map((x) => resolve2(x));
   return [...new Set(list)];
 }
 function parsePluginSha256(input) {
@@ -35170,7 +35680,7 @@ function parsePluginSha256(input) {
     }
     const key = entry.slice(0, idx).trim();
     const value = entry.slice(idx + 1).trim();
-    const abs = resolve(key);
+    const abs = resolve2(key);
     const digest = normalizeSha256(value);
     if (out[abs] && out[abs] !== digest) {
       throw new Error(`Conflicting sha256 values for plugin path: ${key}`);
@@ -35182,7 +35692,7 @@ function parsePluginSha256(input) {
 function parsePluginSecurityOptions(input) {
   const allowedRoots = parsePluginRoots(input.roots);
   const requiredSha256 = parsePluginSha256(input.sha256);
-  const trustFile = typeof input.trustFile === "string" && input.trustFile.trim().length > 0 ? resolve(input.trustFile) : undefined;
+  const trustFile = typeof input.trustFile === "string" && input.trustFile.trim().length > 0 ? resolve2(input.trustFile) : undefined;
   return {
     allowedRoots,
     requiredSha256,
@@ -35204,7 +35714,7 @@ async function loadPluginTrustFile(pathAbs) {
     if (typeof v !== "string")
       continue;
     const digest = normalizeSha256(v);
-    const absPath = isAbsolute(k) ? resolve(k) : resolve(baseDir, k);
+    const absPath = isAbsolute(k) ? resolve2(k) : resolve2(baseDir, k);
     out[absPath] = digest;
   }
   return out;
@@ -35230,7 +35740,7 @@ async function loadRegistries(pluginPaths = [], securityOptions = {}) {
   let requiredSha256;
   let requiredClosureSha256;
   try {
-    allowedRoots = (securityOptions.allowedRoots ?? []).map((x) => resolve(x));
+    allowedRoots = (securityOptions.allowedRoots ?? []).map((x) => resolve2(x));
     const trustFileSha256 = securityOptions.trustFile !== undefined ? await loadPluginTrustFile(securityOptions.trustFile) : {};
     requiredSha256 = mergeShaPolicies(trustFileSha256, securityOptions.requiredSha256 ?? {});
     requiredClosureSha256 = mergeShaPolicies({}, securityOptions.requiredClosureSha256 ?? {});
@@ -35327,6 +35837,7 @@ function isPathInsideRoot(pathAbs, rootAbs) {
   return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
 }
 async function sha256File(pathAbs) {
+  recordInputRead(pathAbs);
   const buffer = await Bun.file(pathAbs).bytes();
   return sha256Hex(buffer);
 }
@@ -35366,11 +35877,16 @@ async function pluginClosureDigest(entryAbs, entryDigest) {
   return sha256Hex(listing.join(`
 `));
 }
+async function recordPluginClosureReads(entryAbs) {
+  try {
+    await pluginClosureDigest(entryAbs, await sha256File(entryAbs));
+  } catch {}
+}
 async function resolveAndValidatePluginPath(input, allowedRoots) {
   if (input.includes("://")) {
     throw new Error(`Plugin path must be a local file path: ${input}`);
   }
-  const abs = resolve(input);
+  const abs = resolve2(input);
   const ext = extname(abs).toLowerCase();
   if (!ALLOWED_PLUGIN_EXTENSIONS.has(ext)) {
     throw new Error(`Unsupported plugin extension '${ext}' for ${input}`);
@@ -35420,7 +35936,7 @@ init_outputMeta();
 
 // src/io/readScenario.ts
 init_dist2();
-import { extname as extname2, resolve as resolve4 } from "path";
+import { extname as extname2, resolve as resolve5 } from "path";
 
 // ../../node_modules/.bun/yaml@2.9.1/node_modules/yaml/dist/index.js
 var exports_dist2 = {};
@@ -35539,7 +36055,7 @@ async function readScenarioFile(path) {
   return out.value;
 }
 async function readScenarioFileWithMeta(path) {
-  const abs = resolve4(path);
+  const abs = resolve5(path);
   const raw = await readTextFile(abs).catch((error) => {
     throw scenarioReadFailedError(abs, error);
   });
@@ -35561,7 +36077,8 @@ async function readScenarioFileWithMeta(path) {
 // src/io/writeOutput.ts
 init_errors3();
 init_bun();
-import { resolve as resolve5 } from "path";
+init_invocation();
+import { resolve as resolve6 } from "path";
 import { realpath, stat } from "fs/promises";
 function toCsv(data) {
   if (!Array.isArray(data)) {
@@ -35624,6 +36141,39 @@ function renderOutput(format, data) {
     return toMarkdown(data);
   return JSON.stringify(data, null, 2);
 }
+async function sameFile(output, input) {
+  try {
+    const [outputReal, inputReal, outputStat, inputStat] = await Promise.all([
+      realpath(output),
+      realpath(input),
+      stat(output, { bigint: true }),
+      stat(input, { bigint: true })
+    ]);
+    return outputReal === inputReal || outputStat.ino !== 0n && outputStat.dev === inputStat.dev && outputStat.ino === inputStat.ino;
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT" && code !== "ENOTDIR")
+      throw error;
+    return false;
+  }
+}
+async function exists(path) {
+  return stat(path).then(() => true, () => false);
+}
+async function assertOutputNotInput(outPath, options = {}) {
+  const abs = resolve6(outPath);
+  const explicit = (options.protectedInputs ?? []).map((input) => ({ input, required: true }));
+  const implicit = invocationInputCandidates({ allow: options.allowFlags }).map((input) => ({ input, required: false }));
+  for (const { input, required } of [...explicit, ...implicit]) {
+    const source = resolve6(input);
+    if (!required && !await exists(source))
+      continue;
+    if (source === abs || await sameFile(abs, source)) {
+      throw usageError(`Output path must not overwrite an input file: ${input}`);
+    }
+  }
+  return abs;
+}
 async function writeOutput(args) {
   const dataWithMeta = args.meta && args.format === "json" && typeof args.data === "object" && args.data !== null && !Array.isArray(args.data) ? {
     ...args.data,
@@ -35635,28 +36185,7 @@ async function writeOutput(args) {
 `);
     return;
   }
-  const abs = resolve5(args.outPath);
-  for (const input of args.protectedInputs ?? []) {
-    const source = resolve5(input);
-    let same = source === abs;
-    if (!same) {
-      try {
-        const [outputReal, inputReal, outputStat, inputStat] = await Promise.all([
-          realpath(abs),
-          realpath(source),
-          stat(abs, { bigint: true }),
-          stat(source, { bigint: true })
-        ]);
-        same = outputReal === inputReal || outputStat.ino !== 0n && outputStat.dev === inputStat.dev && outputStat.ino === inputStat.ino;
-      } catch (error) {
-        const code = error.code;
-        if (code !== "ENOENT" && code !== "ENOTDIR")
-          throw error;
-      }
-    }
-    if (same)
-      throw usageError(`Output path must not overwrite an input file: ${input}`);
-  }
+  const abs = await assertOutputNotInput(args.outPath, { protectedInputs: args.protectedInputs });
   await writeTextFile(abs, body);
   console.log(`Wrote ${args.format} output to ${abs}`);
 }
@@ -36508,7 +37037,7 @@ init_errors3();
 init_outputMeta();
 init_bun();
 import { closeSync as closeSync2, lstatSync as lstatSync2, openSync as openSync2, readlinkSync as readlinkSync2, realpathSync as realpathSync3, statSync, unlinkSync as unlinkSync2 } from "fs";
-import { basename as basename3, dirname as dirname6, resolve as resolve7 } from "path";
+import { basename as basename3, dirname as dirname6, resolve as resolve8 } from "path";
 
 // src/lib/evaluation/input.ts
 init_dist2();
@@ -36538,17 +37067,17 @@ function evaluateRules(input) {
 
 // src/commands/judge.ts
 function canonical(path, depth = 0) {
-  const absolute = resolve7(path);
+  const absolute = resolve8(path);
   try {
     return realpathSync3(absolute);
   } catch {
     try {
       if (depth < 32 && lstatSync2(absolute).isSymbolicLink()) {
-        return canonical(resolve7(dirname6(absolute), readlinkSync2(absolute)), depth + 1);
+        return canonical(resolve8(dirname6(absolute), readlinkSync2(absolute)), depth + 1);
       }
     } catch {}
     const parent = dirname6(absolute);
-    return parent === absolute ? absolute : resolve7(canonical(parent, depth), basename3(absolute));
+    return parent === absolute ? absolute : resolve8(canonical(parent, depth), basename3(absolute));
   }
 }
 function existingDirectory(path) {
@@ -36567,12 +37096,12 @@ function existingDirectory(path) {
 }
 function ignoresCase(directory) {
   const name = `.idlekit-case-${crypto.randomUUID()}`;
-  const path = resolve7(directory, name);
+  const path = resolve8(directory, name);
   let fd;
   try {
     fd = openSync2(path, "wx");
     const original = statSync(path);
-    const folded = statSync(resolve7(directory, name.toUpperCase()));
+    const folded = statSync(resolve8(directory, name.toUpperCase()));
     return original.dev === folded.dev && original.ino === folded.ino;
   } catch {
     return fd === undefined && process.platform === "win32";
@@ -36586,7 +37115,7 @@ function ignoresCase(directory) {
     }
   }
 }
-function sameFile(left, right) {
+function sameFile2(left, right) {
   const aPath = canonical(left);
   const bPath = canonical(right);
   if (aPath === bPath)
@@ -36606,7 +37135,7 @@ function sameFile(left, right) {
 function ancestorFile(parent, child) {
   let directory = dirname6(canonical(child));
   for (;; ) {
-    if (sameFile(parent, directory))
+    if (sameFile2(parent, directory))
       return true;
     const next = dirname6(directory);
     if (next === directory)
@@ -36638,6 +37167,17 @@ function requireFileTarget(path, flag) {
     current = parent;
   }
 }
+function readMetricVersion(diagnostic) {
+  const ref = diagnostic?.evidenceRefs.find((item) => item.startsWith("metric-version:"));
+  if (ref === undefined)
+    return null;
+  const version = Number(ref.slice("metric-version:".length));
+  return Number.isFinite(version) ? version : null;
+}
+function versionLabel(diagnostic) {
+  const version = readMetricVersion(diagnostic);
+  return version === null ? "" : ` (metric version ${version})`;
+}
 function renderJudgeMarkdown(report) {
   const lines = [
     "# Rules judge",
@@ -36651,9 +37191,10 @@ function renderJudgeMarkdown(report) {
     "## Numerical",
     ""
   ];
-  for (const result of report.numerical.results) {
-    lines.push(`- ${result.metricId}: ${result.verdict} ${result.evidence.value ?? "none"} ${result.evidence.unit}`);
-  }
+  report.numerical.results.forEach((result, index) => {
+    const version = versionLabel(report.diagnostics[index]);
+    lines.push(`- ${result.metricId}${version}: ${result.verdict} ${result.evidence.value ?? "none"} ${result.evidence.unit}`);
+  });
   lines.push("", "## Estimates", "");
   if (report.estimatedObservations.length === 0)
     lines.push("None.");
@@ -36662,7 +37203,7 @@ function renderJudgeMarkdown(report) {
   }
   lines.push("", "## Semantic", "");
   for (const diagnostic of report.diagnostics) {
-    lines.push(`- ${diagnostic.status} ${diagnostic.recommendationId}: ${diagnostic.text.en}`);
+    lines.push(`- ${diagnostic.status} ${diagnostic.recommendationId}${versionLabel(diagnostic)}: ${diagnostic.text.en}`);
   }
   return lines.join(`
 `);
@@ -36682,7 +37223,8 @@ function judgeCsvRows(report) {
       threshold: result.evidence.threshold,
       upperThreshold: result.evidence.upperThreshold,
       diagnosticStatus: diagnostic?.status ?? null,
-      recommendationId: diagnostic?.recommendationId ?? null
+      recommendationId: diagnostic?.recommendationId ?? null,
+      metricVersion: readMetricVersion(diagnostic)
     };
   });
 }
@@ -36694,14 +37236,17 @@ async function runJudge(flags, analysisPath, hooks) {
   if (flags.provider === "jev" && flags.format === "csv") {
     throw usageError("--provider jev writes json or md. csv cannot hold the rules report and the advisory together.");
   }
+  const overwritten = flags.out ? [analysisPath, flags.rubric].find((input) => sameFile2(flags.out, input)) : undefined;
+  if (overwritten)
+    throw usageError(`Output path must not overwrite an input file: ${overwritten}`);
   if (flags.provider === "jev" && flags.cache) {
-    if (flags.out && sameFile(flags.cache, flags.out)) {
+    if (flags.out && sameFile2(flags.cache, flags.out)) {
       throw usageError("--cache and --out name the same file. Give the Jev cache its own path.");
     }
     if (flags.out && (ancestorFile(flags.cache, flags.out) || ancestorFile(flags.out, flags.cache))) {
       throw usageError("--cache and --out cannot be ancestor paths. Give each file a separate target.");
     }
-    if (sameFile(flags.cache, analysisPath) || sameFile(flags.cache, flags.rubric)) {
+    if (sameFile2(flags.cache, analysisPath) || sameFile2(flags.cache, flags.rubric)) {
       throw usageError("--cache names an input file. Give the Jev cache its own path.");
     }
   }
@@ -36734,6 +37279,7 @@ async function runJudge(flags, analysisPath, hooks) {
     await writeOutput({
       format: flags.format,
       outPath: flags.out,
+      protectedInputs: [analysisPath, flags.rubric],
       data: flags.format === "md" ? renderJudgeMarkdown(report) : flags.format === "csv" ? judgeCsvRows(report) : report
     });
     return report;
@@ -36773,20 +37319,13 @@ async function runJudge(flags, analysisPath, hooks) {
       ...advisory.answers.length === 0 ? ["None."] : []
     ].join(`
 `);
-    if (flags.out) {
-      const outPath = resolve7(flags.out);
-      await writeTextFile(outPath, `${markdown}
-`);
-      console.log(`Wrote md output to ${outPath}`);
-    } else {
-      await writeStdout(`${markdown}
-`);
-    }
+    await writeOutput({ format: "md", outPath: flags.out, data: markdown, protectedInputs: [analysisPath, flags.rubric] });
     return bundle;
   }
   await writeOutput({
     format: flags.format,
     outPath: flags.out,
+    protectedInputs: [analysisPath, flags.rubric],
     data: bundle,
     meta: buildOutputMeta({
       command: "judge",
@@ -36827,7 +37366,7 @@ var judge_default = defineCommand({
 init_zod();
 init_errors3();
 init_outputMeta();
-import { extname as extname3, resolve as resolve8 } from "path";
+import { extname as extname3, resolve as resolve9 } from "path";
 
 // src/lib/ltvCalibration.ts
 function assertFiniteNumbers(value, path) {
@@ -36858,18 +37397,50 @@ function clampCorrelation2(v) {
 function mean(values) {
   if (values.length === 0)
     return 0;
-  return values.reduce((a, b) => a + b, 0) / values.length;
+  const sum = values.reduce((a, b) => a + b, 0);
+  if (Number.isFinite(sum))
+    return sum / values.length;
+  return values.reduce((a, b) => a + b / values.length, 0);
+}
+function moments(x, y) {
+  const n = Math.min(x.length, y.length);
+  const mx = mean(x.slice(0, n));
+  const my = mean(y.slice(0, n));
+  const sums = (scaleX, scaleY) => {
+    let cov = 0;
+    let vx = 0;
+    let vy = 0;
+    for (let i = 0;i < n; i++) {
+      const dx = ((x[i] ?? 0) - mx) / scaleX;
+      const dy = ((y[i] ?? 0) - my) / scaleY;
+      cov += dx * dy;
+      vx += dx * dx;
+      vy += dy * dy;
+    }
+    return { cov, vx, vy, scaleX, scaleY };
+  };
+  const plain = sums(1, 1);
+  if (Number.isFinite(plain.cov) && Number.isFinite(plain.vx) && Number.isFinite(plain.vy))
+    return plain;
+  let scaleX = 0;
+  let scaleY = 0;
+  for (let i = 0;i < n; i++) {
+    scaleX = Math.max(scaleX, Math.abs((x[i] ?? 0) - mx));
+    scaleY = Math.max(scaleY, Math.abs((y[i] ?? 0) - my));
+  }
+  return sums(scaleX || 1, scaleY || 1);
+}
+function scaledVariance(sum, scale, n) {
+  if (scale === 1)
+    return sum / n;
+  const deviation = scale * Math.sqrt(sum / n);
+  return deviation * deviation;
 }
 function variance(values) {
   if (values.length === 0)
     return 0;
-  const m = mean(values);
-  let acc = 0;
-  for (const v of values) {
-    const d = v - m;
-    acc += d * d;
-  }
-  return acc / values.length;
+  const { vx, scaleX } = moments(values, values);
+  return scaledVariance(vx, scaleX, values.length);
 }
 function estimateCorrelation(x, y) {
   const n = Math.min(x.length, y.length);
@@ -36884,23 +37455,11 @@ function estimateCorrelation(x, y) {
       varianceY: 0
     };
   }
-  const sx = x.slice(0, n);
-  const sy = y.slice(0, n);
-  const mx = mean(sx);
-  const my = mean(sy);
-  let cov = 0;
-  let vx = 0;
-  let vy = 0;
-  for (let i = 0;i < n; i++) {
-    const dx = (sx[i] ?? 0) - mx;
-    const dy = (sy[i] ?? 0) - my;
-    cov += dx * dy;
-    vx += dx * dx;
-    vy += dy * dy;
-  }
-  const varianceX = vx / n;
-  const varianceY = vy / n;
-  if (vx <= 0.000000000001 || vy <= 0.000000000001) {
+  const { cov, vx, vy, scaleX, scaleY } = moments(x.slice(0, n), y.slice(0, n));
+  const varianceX = scaledVariance(vx, scaleX, n);
+  const varianceY = scaledVariance(vy, scaleY, n);
+  const flat = (sum, scale) => scale === 1 ? sum <= 0.000000000001 : scale * Math.sqrt(sum) <= 0.000001;
+  if (flat(vx, scaleX) || flat(vy, scaleY)) {
     return {
       raw: 0,
       value: 0,
@@ -36930,18 +37489,53 @@ function estimateCorrelation(x, y) {
     varianceY
   };
 }
+var FEATURE_SOURCES = {
+  conversion: ["iapRevenue"],
+  arppu: ["iapRevenue"],
+  adArpDau: ["adRevenue"]
+};
+var CORRELATION_SOURCES = {
+  retentionConversion: ["iapRevenue"],
+  retentionArppu: ["iapRevenue"],
+  retentionAd: ["adRevenue"],
+  conversionArppu: ["iapRevenue"],
+  conversionAd: ["iapRevenue", "adRevenue"],
+  arppuAd: ["iapRevenue", "adRevenue"]
+};
+function pickMeasured(keys, measured, value) {
+  const out = {};
+  for (const key of Object.keys(keys)) {
+    if (keys[key].every((source) => measured.has(source)))
+      out[key] = value(key);
+  }
+  return out;
+}
 function calibrateMonetization(rows) {
   if (rows.length === 0) {
     throw new Error("calibration rows cannot be empty");
   }
+  const measured = new Set;
+  for (const source of ["iapRevenue", "adRevenue"]) {
+    const supplied = rows.filter((row) => row[source] !== undefined).length;
+    if (supplied > 0 && supplied < rows.length) {
+      throw new RangeError(`${source} must be supplied on every telemetry row or omitted from every row`);
+    }
+    if (supplied > 0)
+      measured.add(source);
+  }
+  if (rows.some((row) => row.acquisitionCost !== undefined))
+    measured.add("acquisitionCost");
+  const iapMeasured = measured.has("iapRevenue");
+  const adMeasured = measured.has("adRevenue");
+  const revenueMeasured = iapMeasured || adMeasured;
   const users = new Map;
   for (const row of rows) {
     const day = Math.max(0, Math.floor(row.day));
     const u = users.get(row.userId) ?? { days: new Set, iap: 0, ad: 0, acq: undefined };
-    if (row.active ?? true)
+    if ((row.active ?? true) || day === 0)
       u.days.add(day);
-    u.iap += Math.max(0, row.iapRevenue);
-    u.ad += Math.max(0, row.adRevenue);
+    u.iap += Math.max(0, row.iapRevenue ?? 0);
+    u.ad += Math.max(0, row.adRevenue ?? 0);
     if (row.acquisitionCost !== undefined && Number.isFinite(row.acquisitionCost)) {
       u.acq = (u.acq ?? 0) + Math.max(0, row.acquisitionCost);
     }
@@ -36986,52 +37580,25 @@ function calibrateMonetization(rows) {
   const adArpDau = totalAd / Math.max(1, activeUserDays);
   const cpi = totalAcq / Math.max(1, acqUsers);
   const userRetention = [];
-  const userConversion = [];
-  const userArppu = [];
-  const userAdArpDau = [];
+  const features = { conversion: [], arppu: [], adArpDau: [] };
   for (const user of users.values()) {
     const activeDays = Math.max(1, user.days.size);
-    const retentionScore = clamp014(activeDays / 30);
-    const conversionScore = user.iap > 0 ? 1 : 0;
-    const arppuScore = user.iap > 0 ? user.iap / activeDays : 0;
-    const adScore = user.ad / activeDays;
-    userRetention.push(retentionScore);
-    userConversion.push(conversionScore);
-    userArppu.push(arppuScore);
-    userAdArpDau.push(adScore);
-  }
-  const estimatedCorrelationPair = {
-    retentionConversion: estimateCorrelation(userRetention, userConversion),
-    retentionArppu: estimateCorrelation(userRetention, userArppu),
-    retentionAd: estimateCorrelation(userRetention, userAdArpDau),
-    conversionArppu: estimateCorrelation(userConversion, userArppu),
-    conversionAd: estimateCorrelation(userConversion, userAdArpDau),
-    arppuAd: estimateCorrelation(userArppu, userAdArpDau)
-  };
-  const estimatedCorrelation = {
-    retentionConversion: estimatedCorrelationPair.retentionConversion.value,
-    retentionArppu: estimatedCorrelationPair.retentionArppu.value,
-    retentionAd: estimatedCorrelationPair.retentionAd.value,
-    conversionArppu: estimatedCorrelationPair.conversionArppu.value,
-    conversionAd: estimatedCorrelationPair.conversionAd.value,
-    arppuAd: estimatedCorrelationPair.arppuAd.value
-  };
-  const estimatedCorrelationRaw = {
-    retentionConversion: estimatedCorrelationPair.retentionConversion.raw,
-    retentionArppu: estimatedCorrelationPair.retentionArppu.raw,
-    retentionAd: estimatedCorrelationPair.retentionAd.raw,
-    conversionArppu: estimatedCorrelationPair.conversionArppu.raw,
-    conversionAd: estimatedCorrelationPair.conversionAd.raw,
-    arppuAd: estimatedCorrelationPair.arppuAd.raw
-  };
-  const correlationConfidence = {
-    retentionConversion: estimatedCorrelationPair.retentionConversion.confidence,
-    retentionArppu: estimatedCorrelationPair.retentionArppu.confidence,
-    retentionAd: estimatedCorrelationPair.retentionAd.confidence,
-    conversionArppu: estimatedCorrelationPair.conversionArppu.confidence,
-    conversionAd: estimatedCorrelationPair.conversionAd.confidence,
-    arppuAd: estimatedCorrelationPair.arppuAd.confidence
-  };
+    userRetention.push(clamp014(activeDays / 30));
+    features.conversion.push(user.iap > 0 ? 1 : 0);
+    features.arppu.push(user.iap > 0 ? user.iap / activeDays : 0);
+    features.adArpDau.push(user.ad / activeDays);
+  }
+  const correlationInputs = {
+    retentionConversion: [userRetention, features.conversion],
+    retentionArppu: [userRetention, features.arppu],
+    retentionAd: [userRetention, features.adArpDau],
+    conversionArppu: [features.conversion, features.arppu],
+    conversionAd: [features.conversion, features.adArpDau],
+    arppuAd: [features.arppu, features.adArpDau]
+  };
+  const estimatedCorrelationPair = pickMeasured(CORRELATION_SOURCES, measured, (key) => estimateCorrelation(...correlationInputs[key]));
+  const correlationField = (field) => pickMeasured(CORRELATION_SOURCES, measured, (key) => estimatedCorrelationPair[key][field]);
+  const estimatedCorrelation = correlationField("value");
   const result = {
     monetization: {
       cohorts: {
@@ -37044,44 +37611,38 @@ function calibrateMonetization(rows) {
         d90: clamp014(Math.min(d1, d7, d30, d90)),
         longTailDailyDecay: 0.02
       },
-      revenue: {
-        payerConversion: clamp014(payerConversion),
-        arppuDaily: Math.max(0, arppuDaily),
-        adArpDau: Math.max(0, adArpDau),
-        platformFeeRate: 0.3,
-        grossMarginRate: 0.92
-      },
-      acquisition: {
-        cpi: Math.max(0, cpi)
-      },
-      uncertainty: {
-        enabled: true,
-        draws: 300,
-        quantiles: [0.5, 0.9],
-        sigma: {
-          retention: 0.08,
-          conversion: 0.12,
-          arppu: 0.2,
-          ad: 0.15
-        },
-        correlation: {
-          retentionConversion: estimatedCorrelation.retentionConversion,
-          retentionArppu: estimatedCorrelation.retentionArppu,
-          retentionAd: estimatedCorrelation.retentionAd,
-          conversionArppu: estimatedCorrelation.conversionArppu,
-          conversionAd: estimatedCorrelation.conversionAd,
-          arppuAd: estimatedCorrelation.arppuAd
+      ...revenueMeasured ? {
+        revenue: {
+          ...iapMeasured ? { payerConversion: clamp014(payerConversion), arppuDaily: Math.max(0, arppuDaily) } : {},
+          ...adMeasured ? { adArpDau: Math.max(0, adArpDau) } : {},
+          platformFeeRate: 0.3,
+          grossMarginRate: 0.92
         }
-      }
+      } : {},
+      ...measured.has("acquisitionCost") ? { acquisition: { cpi: Math.max(0, cpi) } } : {},
+      ...revenueMeasured ? {
+        uncertainty: {
+          enabled: true,
+          draws: 300,
+          quantiles: [0.5, 0.9],
+          sigma: {
+            retention: 0.08,
+            conversion: 0.12,
+            arppu: 0.2,
+            ad: 0.15
+          },
+          correlation: estimatedCorrelation
+        }
+      } : {}
     },
     diagnostics: {
       users: cohortSize,
       totalRows: rows.length,
-      totalIap,
-      totalAd,
+      ...iapMeasured ? { totalIap } : {},
+      ...adMeasured ? { totalAd } : {},
       activeUserDays,
-      payerUsers,
-      payerDays,
+      ...iapMeasured ? { payerUsers, payerDays } : {},
+      ...measured.size < 3 ? { unmeasured: ["iapRevenue", "adRevenue", "acquisitionCost"].filter((source) => !measured.has(source)) } : {},
       retention: {
         d1,
         d7,
@@ -37090,14 +37651,14 @@ function calibrateMonetization(rows) {
       },
       userFeatureVariance: {
         retention: variance(userRetention),
-        conversion: variance(userConversion),
-        arppu: variance(userArppu),
-        adArpDau: variance(userAdArpDau)
+        ...pickMeasured(FEATURE_SOURCES, measured, (key) => variance(features[key]))
       },
-      estimatedCorrelation,
-      estimatedCorrelationRaw,
-      correlationConfidence,
-      correlationDiagnostics: estimatedCorrelationPair
+      ...revenueMeasured ? {
+        estimatedCorrelation,
+        estimatedCorrelationRaw: correlationField("raw"),
+        correlationConfidence: correlationField("confidence"),
+        correlationDiagnostics: estimatedCorrelationPair
+      } : {}
     }
   };
   assertFiniteNumbers(result, "calibration");
@@ -37108,115 +37669,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 = [
@@ -37348,13 +37801,14 @@ function parseCsvTelemetry(raw, strictCohort = false) {
       throw usageError("Observed cohort requires explicit user_id and day fields");
     const userId = userInput ?? `anon-${i}`;
     const dayRaw = dayInput ?? "0";
-    const iapRaw = pick2(rec, ["iap_revenue", "revenue", "iap", "purchase_revenue"]) ?? "0";
-    const adRaw = pick2(rec, ["ad_revenue", "adrevenue", "ads"]) ?? "0";
+    const missingRevenue = strictCohort ? undefined : "0";
+    const iapRaw = pick2(rec, ["iap_revenue", "revenue", "iap", "purchase_revenue"]) ?? missingRevenue;
+    const adRaw = pick2(rec, ["ad_revenue", "adrevenue", "ads"]) ?? missingRevenue;
     const activeRaw = pick2(rec, ["active", "is_active"]);
     const acqRaw = pick2(rec, ["acquisition_cost", "ua_cost", "cpi"]);
     const day = parseNumeric(dayRaw, i + 1, "day");
-    const iapRevenue = parseNumeric(iapRaw, i + 1, "revenue");
-    const adRevenue = parseNumeric(adRaw, i + 1, "ad_revenue");
+    const iapRevenue = iapRaw === undefined ? undefined : parseNumeric(iapRaw, i + 1, "revenue");
+    const adRevenue = adRaw === undefined ? undefined : parseNumeric(adRaw, i + 1, "ad_revenue");
     const acquisitionCost = acqRaw !== undefined ? parseNumeric(acqRaw, i + 1, "acquisition_cost", { allowEmpty: true }) : undefined;
     const active = parseActive(activeRaw, strictCohort);
     rows.push({
@@ -37390,11 +37844,14 @@ function parseJsonTelemetry(raw, strictCohort = false) {
       }
     const userId = String(userInput ?? `anon-${idx}`);
     const day = Number(dayInput ?? 0);
-    const iapRevenue = Number(r.iapRevenue ?? r.iap_revenue ?? r.revenue ?? 0);
-    const adRevenue = Number(r.adRevenue ?? r.ad_revenue ?? 0);
+    const missingRevenue = strictCohort ? undefined : 0;
+    const iapInput = r.iapRevenue ?? r.iap_revenue ?? r.revenue ?? missingRevenue;
+    const adInput = r.adRevenue ?? r.ad_revenue ?? missingRevenue;
+    const iapRevenue = iapInput === undefined ? undefined : Number(iapInput);
+    const adRevenue = adInput === undefined ? undefined : Number(adInput);
     const acquisitionCost = r.acquisitionCost !== undefined || r.acquisition_cost !== undefined || r.cpi !== undefined ? Number(r.acquisitionCost ?? r.acquisition_cost ?? r.cpi) : undefined;
     const active = parseActive(r.active, strictCohort);
-    if (!Number.isFinite(day) || !Number.isFinite(iapRevenue) || !Number.isFinite(adRevenue)) {
+    if (!Number.isFinite(day) || ![iapRevenue, adRevenue].every((v) => v === undefined || Number.isFinite(v))) {
       throw cliError("CLI_USAGE", `Invalid numeric value in json row ${idx}`);
     }
     rows.push({
@@ -37429,7 +37886,7 @@ var calibrate_default = defineCommand({
     }
     if (flags.scenario && flags["observed-through-day"] === undefined)
       throw usageError("--scenario requires --observed-through-day for a mature cohort comparison");
-    const abs = resolve8(process.cwd(), telemetryPath);
+    const abs = resolve9(process.cwd(), telemetryPath);
     const raw = await readTextFile(abs);
     const format = flags["input-format"] === "auto" ? extname3(abs).toLowerCase() : flags["input-format"];
     const rows = format === ".csv" || format === "csv" ? parseCsvTelemetry(raw, flags["observed-through-day"] !== undefined) : parseJsonTelemetry(raw, flags["observed-through-day"] !== undefined);
@@ -37468,12 +37925,12 @@ var calibrate_default = defineCommand({
       command: "calibrate",
       telemetry: observation ? { rows, observedThroughDay: observation.observedThroughDay } : rows,
       scenario,
-      scenarioPath: flags.scenario ? resolve8(flags.scenario) : undefined
+      scenarioPath: flags.scenario ? resolve9(flags.scenario) : undefined
     });
     await writeOutput({
       format: flags.format,
       outPath: flags.out,
-      protectedInputs: [abs, ...flags.scenario ? [resolve8(flags.scenario)] : []],
+      protectedInputs: [abs, ...flags.scenario ? [resolve9(flags.scenario)] : []],
       data: flags.format === "json" ? {
         ok: true,
         source: abs,
@@ -37513,7 +37970,7 @@ var calibrate_default = defineCommand({
           payerConversion: (calibrated.monetization?.revenue?.payerConversion ?? 0).toFixed(4),
           arppuDaily: (calibrated.monetization?.revenue?.arppuDaily ?? 0).toFixed(4),
           adArpDau: (calibrated.monetization?.revenue?.adArpDau ?? 0).toFixed(4),
-          cpi: (calibrated.monetization?.acquisition?.cpi ?? 0).toFixed(4)
+          cpi: calibrated.monetization?.acquisition?.cpi?.toFixed(4) ?? ""
         }
       ],
       meta: outputMeta
@@ -37523,12 +37980,12 @@ var calibrate_default = defineCommand({
 
 // src/commands/balance.ts
 init_zod();
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 
 // src/balance/workflow.ts
 init_dist2();
 init_zod();
-import { resolve as resolve10, dirname as dirname8 } from "path";
+import { resolve as resolve11, dirname as dirname8 } from "path";
 import { stat as stat2 } from "fs/promises";
 
 // src/cliMeta.ts
@@ -37541,6 +37998,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+))(?:e([+-]?\d+))?$/i;
+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 +38075,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 +38139,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 +38222,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);
@@ -37776,7 +38276,7 @@ async function runPacingChecks(input, evaluator) {
 init_bun();
 import { constants } from "fs";
 import { lstat, mkdir, open as open2, realpath as realpath2, rename, rm } from "fs/promises";
-import { dirname as dirname7, isAbsolute as isAbsolute2, join, relative as relative2, resolve as resolve9, sep as sep2 } from "path";
+import { dirname as dirname7, isAbsolute as isAbsolute2, join, relative as relative2, resolve as resolve10, sep as sep2 } from "path";
 var SHEET_LIMITS = Object.freeze({
   maxCsvBytes: 2 * 1024 * 1024,
   maxRows: 10001,
@@ -38148,7 +38648,7 @@ async function snapshotInputs(inputFiles, contextValue, limits) {
   const inputs = Object.create(null);
   let total = 0;
   for (const name of validInputNames(inputFiles, limits)) {
-    const path = resolve9(inputFiles[name]);
+    const path = resolve10(inputFiles[name]);
     const realPath = await realpath2(path);
     const bytes = await boundedRead(realPath, Math.min(limits.maxInputBytes, limits.maxTotalInputBytes - total));
     total += bytes.length;
@@ -38174,7 +38674,7 @@ async function snapshotInputs(inputFiles, contextValue, limits) {
   });
 }
 async function canonicalOutput(path) {
-  path = resolve9(path);
+  path = resolve10(path);
   try {
     return await realpath2(path);
   } catch (error) {
@@ -38213,7 +38713,7 @@ async function refreshSheetBundle(options) {
   validInputNames(options.inputFiles, limits);
   const output = await canonicalOutput(options.outputDir);
   for (const [name, path] of Object.entries(options.inputFiles)) {
-    if (isWithin(output, resolve9(path)) || isWithin(output, await realpath2(path)))
+    if (isWithin(output, resolve10(path)) || isWithin(output, await realpath2(path)))
       throw new Error(`Output/input collision: ${name}`);
   }
   await mkdir(output, { recursive: true });
@@ -38473,7 +38973,7 @@ function normalizeRunDocument(document, strategy, horizon) {
   target.outputs = { ...target.outputs, report: { ...target.outputs?.report, includeTrace: true, traceEverySteps: MAX_STEPS_PER_RUN + 1 } };
 }
 async function refreshBalanceWorkflow(configPath, flags, check = false) {
-  const absoluteConfig = resolve10(configPath);
+  const absoluteConfig = resolve11(configPath);
   const configInfo = await stat2(absoluteConfig);
   if (!configInfo.isFile() || configInfo.size > SHEET_LIMITS.maxInputBytes)
     throw new Error("Workflow config is not a bounded regular file");
@@ -38482,17 +38982,18 @@ async function refreshBalanceWorkflow(configPath, flags, check = false) {
   const base = dirname8(absoluteConfig);
   const inputFiles = {
     config: absoluteConfig,
-    sheet: resolve10(base, config.sheet),
-    schema: resolve10(base, config.schema),
-    scenario: resolve10(base, config.scenario)
+    sheet: resolve11(base, config.sheet),
+    schema: resolve11(base, config.schema),
+    scenario: resolve11(base, config.scenario)
   };
   if (flags["plugin-trust-file"])
-    inputFiles.pluginTrust = resolve10(flags["plugin-trust-file"]);
+    inputFiles.pluginTrust = resolve11(flags["plugin-trust-file"]);
   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 outputDir = resolve10(base, config.outputDir);
+  const engine = resolveEffectiveEngine({ requested: flags.engine });
+  const context = { cliVersion: CLI_VERSION, bunVersion: Bun.version, pluginDigests: JSON.stringify(loaded.pluginDigest), engine: engine.effectiveId };
+  const outputDir = resolve11(base, config.outputDir);
   if (check)
     return readCurrentBundle(outputDir, inputFiles, { context });
   let outcome;
@@ -38528,7 +39029,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 +39051,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 +39071,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 +39093,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 +39109,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 +39172,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;
@@ -38674,12 +39185,24 @@ async function refreshBalanceWorkflow(configPath, flags, check = false) {
 function cell(value) {
   return String(value).replaceAll("|", "\\|").replace(/[\r\n]/g, " ");
 }
+function decimals(value) {
+  const [mantissa = "", exponent = "0"] = String(value).split("e");
+  return Math.max(0, (mantissa.split(".")[1]?.length ?? 0) - Number(exponent));
+}
+function gap(larger, smaller) {
+  const difference = larger - smaller;
+  if (!Number.isFinite(difference) || difference === 0)
+    return difference;
+  const lastPlace = Math.max(decimals(larger), decimals(smaller));
+  const digits = lastPlace + Math.floor(Math.log10(Math.abs(difference))) + 1;
+  return Number(difference.toPrecision(Math.min(17, Math.max(1, digits))));
+}
 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 ${gap(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 ${gap(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 +39241,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" })
   },
@@ -38725,7 +39249,7 @@ var balance_default = defineCommand({
     if (positional.length !== 1)
       throw usageError("Usage: idk balance <workflow.json> [--check] [plugin options]");
     const result = await refreshBalanceWorkflow(positional[0], flags, flags.check);
-    const body = flags.format === "json" ? JSON.stringify(result, null, 2) : ("state" in result) ? renderBalanceFreshness(result) : renderBalanceReport(JSON.parse(await readTextFile(resolve11(result.generationPath, "results.json"))), result.generationPath);
+    const body = flags.format === "json" ? JSON.stringify(result, null, 2) : ("state" in result) ? renderBalanceFreshness(result) : renderBalanceReport(JSON.parse(await readTextFile(resolve12(result.generationPath, "results.json"))), result.generationPath);
     await writeStdout(body + `
 `);
     if (flags.check && "state" in result && result.state !== "current")
@@ -38770,7 +39294,6 @@ import { resolve as resolve13 } from "path";
 // src/io/replayArtifact.ts
 init_outputMeta();
 init_bun();
-import { resolve as resolve12 } from "path";
 var REDACTED_KEYS = new Set([
   "generatedAt",
   "scenario",
@@ -38836,7 +39359,7 @@ function toReplayCommandLine(args) {
   return `bun run --cwd packages/cli dev -- ${rendered}`;
 }
 async function writeReplayArtifact(args) {
-  const abs = resolve12(args.outPath);
+  const abs = await assertOutputNotInput(args.outPath);
   const runId = args.meta.runId;
   const seed = args.meta.seed;
   const scenarioHash = args.meta.scenarioHash;
@@ -39174,6 +39697,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,
@@ -39181,7 +39705,13 @@ function compareIdentity2(args) {
     milestoneKey: metrics.includes("timeToMilestone") ? compareMilestoneKey(flags) ?? null : null
   };
 }
+function requireFiniteAmount(E, amount, label) {
+  if (!E.isFinite(amount))
+    throw new RangeError(`compare ${label} must be finite in the selected engine`);
+  return amount;
+}
 function measureScenario(args) {
+  const requireFinite = (amount, label) => requireFiniteAmount(args.E, amount, label);
   const runInput = args.compiled.fresh("economy");
   const run = runScenario(runInput);
   const endWorth = runInput.model.netWorth?.(runInput.ctx, run.end) ?? run.end.wallet.money;
@@ -39193,7 +39723,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: {
@@ -39377,9 +39912,9 @@ function bundleMetrics(bundle) {
 function compareDecisionForMetric(args) {
   switch (args.metric) {
     case "endMoney":
-      return betterFromCmp(args.E.cmp(args.ma.endMoney, args.mb.endMoney));
+      return betterFromCmp(args.E.cmp(requireFiniteAmount(args.E, args.ma.endMoney, "end money"), requireFiniteAmount(args.E, args.mb.endMoney, "end money")));
     case "endNetWorth":
-      return betterFromCmp(args.E.cmp(args.ma.endNetWorth, args.mb.endNetWorth));
+      return betterFromCmp(args.E.cmp(requireFiniteAmount(args.E, args.ma.endNetWorth, "end net worth"), requireFiniteAmount(args.E, args.mb.endNetWorth, "end net worth")));
     case "droppedRate":
       return betterFromCmp(args.ma.droppedRate < args.mb.droppedRate ? 1 : args.ma.droppedRate > args.mb.droppedRate ? -1 : 0);
     case "etaToTargetWorth": {
@@ -39453,7 +39988,7 @@ function buildSingleCompareOutput(args) {
     },
     insights: buildCompareInsights({
       metric: args.metric,
-      endNetWorthWinner: betterFromCmp(args.E.cmp(args.ma.endNetWorth, args.mb.endNetWorth)),
+      endNetWorthWinner: args.E.isFinite(args.ma.endNetWorth) && args.E.isFinite(args.mb.endNetWorth) ? betterFromCmp(args.E.cmp(args.ma.endNetWorth, args.mb.endNetWorth)) : "tie",
       better: result.better,
       a: {
         endNetWorth: args.E.toString(args.ma.endNetWorth),
@@ -39475,6 +40010,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 +40066,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 +40087,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,
@@ -39627,7 +40167,8 @@ var compare_default = defineCommand({
         a: aScenario,
         b: bScenario
       },
-      pluginDigest: loaded.pluginDigest
+      pluginDigest: loaded.pluginDigest,
+      effectiveEngine: engine.effectiveId
     });
     const markdownWarnings = new Set;
     if (selectedMetrics.some((metric) => ["endMoney", "endNetWorth", "droppedRate"].includes(metric))) {
@@ -39637,6 +40178,9 @@ var compare_default = defineCommand({
         markdownWarnings.add(`Economy runs cover different elapsed durations (A: ${aElapsed}s, B: ${bElapsed}s); end values are not normalized to a common horizon.`);
       }
     }
+    if ([ma.endMoney, ma.endNetWorth, mb.endMoney, mb.endNetWorth].some((amount) => !E.isFinite(amount))) {
+      markdownWarnings.add("The full-duration economy run left the selected engine's finite range; its end values are reported but not ranked.");
+    }
     const singleResults = selectedMetrics.map((metric) => {
       const design = getDesignPair(metric);
       if (design) {
@@ -39732,8 +40276,8 @@ init_outputMeta();
 // src/lib/setup.ts
 init_errors3();
 init_bun();
-init_selfCli();
 import { basename as basename4, dirname as dirname9, relative as relative3, resolve as resolve15 } from "path";
+init_selfCli();
 var START_MARKER = "# >>> idk completions >>>";
 var END_MARKER = "# <<< idk completions <<<";
 function userHome() {
@@ -39874,7 +40418,7 @@ async function writePluginTrust(args) {
   if (args.plugins.length === 0) {
     throw usageError("setup plugin-trust requires at least one --plugin path.");
   }
-  const outPath = resolve15(args.outPath);
+  const outPath = await assertOutputNotInput(args.outPath, { protectedInputs: args.plugins });
   if (await fileExists(outPath) && !args.force) {
     throw usageError(`Output file already exists: ${outPath}`, "Pass --force true to overwrite.");
   }
@@ -40375,6 +40919,9 @@ import { resolve as resolve17 } from "path";
 init_errors3();
 init_outputMeta();
 var strategySchema2 = string2().min(1).optional();
+function uint32Seed(seed) {
+  return Number.isFinite(seed) ? seed >>> 0 : seed;
+}
 function parseHorizonToken(raw) {
   const token = raw.trim().toLowerCase();
   if (!token)
@@ -40530,7 +41077,7 @@ function runLtvAnalysis(args) {
     }
     const worth = args.compiled.model.netWorth?.(args.compiled.ctx, state) ?? state.wallet.money;
     const endWorthLog10 = args.compiled.ctx.E.absLog10(worth.amount);
-    const progression = progressionFactor(startWorthLog10, endWorthLog10, monetizationConfig.revenue.progressionLogSpan);
+    const progression = progressionFactor2(startWorthLog10, endWorthLog10, monetizationConfig.revenue.progressionLogSpan);
     const horizonDays = h.seconds / 86400;
     const point = estimateLtvPerUser2({
       config: monetizationConfig,
@@ -40543,7 +41090,7 @@ function runLtvAnalysis(args) {
       progression,
       draws,
       quantiles: monetizationConfig.uncertainty.quantiles,
-      seed: (args.seed ?? monetizationConfig.uncertainty.seed ?? 1) + h.seconds
+      seed: uint32Seed((args.seed ?? monetizationConfig.uncertainty.seed ?? 1) + h.seconds)
     }) : undefined;
     const E = args.compiled.ctx.E;
     const deltaWorth = E.sub(worth.amount, previousWorth.amount);
@@ -41117,6 +41664,8 @@ var evaluate_default = defineCommand({
       files.ltv = resolve18(outDir, "ltv.json");
       const summaryPath = resolve18(process.cwd(), flags["out-dir"], flags.format === "md" ? "summary.md" : "summary.json");
       files.summary = summaryPath;
+      for (const path of [files.simulate, files.experience, files.ltv, summaryPath])
+        await assertOutputNotInput(path);
       await writeTextFile(files.simulate, `${JSON.stringify({ ...simulate, _meta: simulateMeta }, null, 2)}
 `);
       await writeTextFile(files.experience, `${JSON.stringify({ ...experience, _meta: experienceMeta }, null, 2)}
@@ -41851,7 +42400,7 @@ var simulate_default = defineCommand({
           state: strategyState
         } : undefined
       });
-      await writeTextFile(stateOutPath, `${JSON.stringify(serialized, null, 2)}
+      await writeTextFile(await assertOutputNotInput(stateOutPath, { allowFlags: ["resume"] }), `${JSON.stringify(serialized, null, 2)}
 `);
     }
     const offlineSummary = buildOfflineSummary(offlineRun);
@@ -42096,6 +42645,13 @@ function readBestScoreFromArtifact(x) {
   }
   return score;
 }
+function readEngineFromArtifact(x) {
+  const recorded = x?.meta?.effectiveEngine;
+  if (typeof recorded === "string" && recorded.trim())
+    return recorded.trim();
+  const requested = x?.input?.flags?.engine;
+  return typeof requested === "string" && requested.trim() ? requested.trim() : "number";
+}
 function buildTuneInsights(outputBase) {
   const report = outputBase.report;
   const bestScore = readBestScoreFromTuneResult(outputBase);
@@ -42190,6 +42746,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 +42802,22 @@ 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 });
+    if (baselineRaw !== undefined) {
+      const baselineEngine = readEngineFromArtifact(baselineRaw);
+      if (baselineEngine !== engine.effectiveId) {
+        throw cliError("CLI_USAGE", `Baseline artifact engine mismatch: expected ${engine.effectiveId}, got ${baselineEngine}`, {
+          hint: `Pass --engine ${baselineEngine} to compare against this baseline, or record a new baseline with --engine ${engine.effectiveId}.`
+        });
+      }
+    }
+    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 +42825,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",
@@ -42266,10 +42834,11 @@ var tune_default = defineCommand({
       tuneSpec: tuneSpecInput,
       runId,
       seed,
-      pluginDigest: loaded.pluginDigest
+      pluginDigest: loaded.pluginDigest,
+      effectiveEngine: engine.effectiveId
     });
     const result = await cmdTune({
-      E: createNumberEngine(),
+      E: engine.engine,
       scenarioInput,
       tuneSpecInput,
       modelRegistry: loaded.modelRegistry,
@@ -43658,7 +44227,6 @@ init_zod();
 // src/commands/_shared/listOutput.ts
 init_outputMeta();
 init_bun();
-import { resolve as resolve25 } from "path";
 async function writeListOutput(args) {
   const outputForRender = args.format === "json" ? {
     ...args.payload,
@@ -43669,7 +44237,7 @@ async function writeListOutput(args) {
     process.stdout.write(body);
     return;
   }
-  const path = resolve25(args.out);
+  const path = await assertOutputNotInput(args.out);
   await writeTextFile(path, body);
   console.log(`Wrote ${args.format} output to ${path}`);
 }
@@ -43818,8 +44386,9 @@ var objectives_default2 = defineGroup({
 init_zod();
 init_errors3();
 init_outputMeta();
-import { resolve as resolve26 } from "path";
+import { resolve as resolve25 } from "path";
 init_bun();
+init_invocation();
 init_selfCli();
 function deepEqual(a, b) {
   return stableStringify(a) === stableStringify(b);
@@ -43839,6 +44408,7 @@ function parseArtifact(input) {
       flags: record(string2(), unknown())
     }),
     replay: object({
+      cwd: string2().optional(),
       args: array(string2()).min(1),
       commandLine: string2(),
       verify: object({
@@ -43885,13 +44455,15 @@ var replayVerify_default = defineCommand({
     if (!artifactPath) {
       throw usageError("Usage: idk replay verify <artifact.json>");
     }
-    const artifactAbs = resolve26(process.cwd(), artifactPath);
+    const artifactAbs = resolve25(process.cwd(), artifactPath);
     const raw = await readJsonFile(artifactAbs).catch((error) => {
       if (error instanceof Error && error.name === "CliError")
         throw error;
       throw replayArtifactInvalidError("Invalid replay artifact.", errorDetail(error), error);
     });
     const artifact = parseArtifact(raw);
+    const recordedCwd = artifact.replay.cwd || process.cwd();
+    recordNestedInputs(recordedCwd, artifact.input.positional, artifact.input.flags);
     const requiredChecks = {
       runId: typeof artifact.replay.verify.runId === "string" && artifact.replay.verify.runId.length > 0,
       seed: typeof artifact.replay.verify.seed === "number" && Number.isFinite(artifact.replay.verify.seed),
@@ -43907,6 +44479,15 @@ var replayVerify_default = defineCommand({
     const expectedHash = artifact.replay.verify.resultHash ?? hashReplayResult(expectedCanonical);
     const actualHash = hashReplayResult(actualCanonical);
     const replayMeta = replayOutput && typeof replayOutput === "object" && !Array.isArray(replayOutput) ? replayOutput._meta : undefined;
+    const replayScenarios = replayMeta?.scenarioPath;
+    const replayPlugins = replayMeta?.pluginDigest;
+    const pluginEntries = replayPlugins && typeof replayPlugins === "object" ? Object.keys(replayPlugins) : [];
+    recordNestedInputs(cliPackageRoot(), [
+      ...typeof replayScenarios === "string" ? [replayScenarios] : Array.isArray(replayScenarios) ? replayScenarios.filter((path) => typeof path === "string") : [],
+      ...pluginEntries
+    ], {});
+    for (const entry of pluginEntries)
+      await recordPluginClosureReads(resolve25(cliPackageRoot(), entry));
     const semanticChecks = {
       runId: replayMeta && typeof replayMeta.runId === "string" && replayMeta.runId === artifact.replay.verify.runId,
       seed: replayMeta && typeof replayMeta.seed === "number" && replayMeta.seed === artifact.replay.verify.seed,
@@ -44186,4 +44767,4 @@ export {
   cli2 as cli
 };
 
-//# debugId=A3CAAFDF1955C7F064756E2164756E21
+//# debugId=75B3E1ECDA8A1B6D64756E2164756E21