@agentsgot/agent-kit 0.0.0-stage → 1.0.1

package/vendor/shared/dist/rules/index.js

@@ -0,0 +1,802 @@
+import { AcceptanceGrade, AllocationMode, ArbitrationRound, TaskTemplate, Tier, } from "../schemas/index.js";
+import { agtToWei } from "../units.js";
+import { checkSpecContent } from "./spec-content.js";
+export * from "./spec-content.js";
+export * from "./task-risk.js";
+const BPS = 10_000;
+const SECONDS_PER_DAY = 86_400;
+/** ParamRegistry stores fees as whole AGT; we scale to 18-decimal wei for ERC-20 compatibility. */
+const AGT_UNIT = 10n ** 18n;
+const tierRank = { T1: 1, T2: 2, T3: 3, T4: 4, T5: 5 };
+const tiers = [Tier.T1, Tier.T2, Tier.T3, Tier.T4, Tier.T5];
+function parameter(params, key) {
+    const value = params[key];
+    if (value === null)
+        throw new Error(`Parameter ${key} has no numeric value`);
+    return value;
+}
+function nonnegative(value, name) {
+    if (value < 0n)
+        throw new RangeError(`${name} must be nonnegative`);
+    return value;
+}
+function bpsDown(value, bps) {
+    if (!Number.isInteger(bps) || bps < 0)
+        throw new RangeError("bps must be a nonnegative integer");
+    return (value * BigInt(bps)) / BigInt(BPS);
+}
+// ---------------------------------------------------------------------------
+// Tier helpers
+// ---------------------------------------------------------------------------
+/** Returns the tier daily fee in 18-decimal wei (params stores whole AGT). */
+export function tierDailyFee(tier, params) {
+    return BigInt(parameter(params, `tierDailyFee.${tier}`)) * AGT_UNIT;
+}
+export function snapshotDailyFees(params) {
+    return Object.fromEntries(tiers.map((tier) => [tier, tierDailyFee(tier, params)]));
+}
+/** A task's snapshot fee when known, otherwise the current parameter (only valid before creation). */
+function dailyFee(tier, params, fees) {
+    return fees?.[tier] ?? tierDailyFee(tier, params);
+}
+export function tierDaysRange(tier, params) {
+    return {
+        min: parameter(params, `tierDaysMin.${tier}`),
+        max: parameter(params, `tierDaysMax.${tier}`),
+    };
+}
+export function tierBaseQuota(tier, params) {
+    if (tierRank[tier] >= 3)
+        return parameter(params, "tierBaseQuota.T3");
+    return parameter(params, `tierBaseQuota.${tier}`);
+}
+export function tierSubmissionLimit(tier, params) {
+    return tierBaseQuota(tier, params) * parameter(params, "submissionMultiplier");
+}
+export function participantLimits(params) {
+    return {
+        min: parameter(params, "participantsMin"),
+        default: parameter(params, "participantsDefault"),
+        warning: parameter(params, "participantsWarning"),
+        max: parameter(params, "participantsMax"),
+    };
+}
+/** `maxParticipants` value that removes the cap; the task then closes only by deadline or early close. */
+export const UNLIMITED_PARTICIPANTS = 0;
+/** Resolves the publisher's cap independently of task tier; `null` means unlimited. */
+export function resolveParticipantLimit(value, params) {
+    const limits = participantLimits(params);
+    const resolved = value ?? limits.default;
+    if (resolved === UNLIMITED_PARTICIPANTS)
+        return null;
+    if (!Number.isInteger(resolved) || resolved < limits.min || resolved > limits.max) {
+        throw new RangeError(`maxParticipants must be ${UNLIMITED_PARTICIPANTS} (unlimited) or an integer in [${limits.min}, ${limits.max}]`);
+    }
+    return resolved;
+}
+export function reviewerCount(tier, params) {
+    if (tierRank[tier] >= 3)
+        return parameter(params, "reviewerCount.T3");
+    return parameter(params, `reviewerCount.${tier}`);
+}
+// ---------------------------------------------------------------------------
+// Minimum tier calculation (§3.4)
+// ---------------------------------------------------------------------------
+function criteriaTier(criteria) {
+    const cCount = criteria.filter(({ grade }) => grade === AcceptanceGrade.C).length;
+    const bCount = criteria.filter(({ grade }) => grade === AcceptanceGrade.B).length;
+    const total = criteria.length;
+    if (total === 0)
+        return Tier.T1;
+    const cPct = (cCount / total) * 100;
+    const bPct = (bCount / total) * 100;
+    if (cPct > 30)
+        return Tier.T3;
+    if (cPct > 0 || bPct > 30)
+        return Tier.T2;
+    return Tier.T1;
+}
+function hoursTier(hours) {
+    if (hours <= 1)
+        return Tier.T1;
+    if (hours <= 6)
+        return Tier.T2;
+    if (hours <= 72)
+        return Tier.T3;
+    if (hours <= 168)
+        return Tier.T4;
+    return Tier.T5;
+}
+function templateBaseline(template) {
+    if (template === TaskTemplate.Translation || template === TaskTemplate.DataProcessing)
+        return Tier.T1;
+    if (template === TaskTemplate.Research)
+        return Tier.T2;
+    if (template === TaskTemplate.CodeFix)
+        return Tier.T3;
+    return Tier.T1;
+}
+function maxTier(...levels) {
+    return levels.reduce((highest, level) => (tierRank[level] > tierRank[highest] ? level : highest));
+}
+export function computeMinimumTier(input) {
+    return maxTier(criteriaTier(input.criteria), hoursTier(input.estimatedHours), templateBaseline(input.template));
+}
+export function computeTierRangeMax(minimumTier, params) {
+    const offset = parameter(params, "tierRangeOffset");
+    const maxRank = Math.min(tierRank[minimumTier] + offset, 5);
+    return tiers[maxRank - 1];
+}
+// ---------------------------------------------------------------------------
+// Reserve & deduction (§4.1–4.3)
+// ---------------------------------------------------------------------------
+export function computeReserve(maxTier, runDays, params) {
+    if (runDays <= 0)
+        throw new RangeError("runDays must be positive");
+    return tierDailyFee(maxTier, params) * BigInt(runDays);
+}
+export function computeDeduction(lockedTier, billedSeconds, params, fees) {
+    nonnegative(billedSeconds, "billedSeconds");
+    const fee = dailyFee(lockedTier, params, fees);
+    return (fee * billedSeconds) / BigInt(SECONDS_PER_DAY);
+}
+export function computeSegmentedDeduction(segments, params, fees) {
+    let total = 0n;
+    for (const seg of segments) {
+        nonnegative(seg.seconds, "segment.seconds");
+        total += (dailyFee(seg.tier, params, fees) * seg.seconds) / BigInt(SECONDS_PER_DAY);
+    }
+    return total;
+}
+export function computeSubmissionScore(criterionScores, passingThreshold, params) {
+    let weighted = 0;
+    let allAPass = true;
+    for (const cs of criterionScores) {
+        weighted += cs.weightBps * cs.score;
+        if (cs.grade === AcceptanceGrade.A && cs.score < 1)
+            allAPass = false;
+    }
+    const total = weighted / BPS;
+    const junk = parameter(params, "junkThreshold");
+    const isJunk = total < junk;
+    return {
+        total,
+        passes: allAPass && total >= passingThreshold,
+        isJunk,
+        rewardEligible: allAPass && !isJunk,
+    };
+}
+export function allocateExecutorPool(pool, scores, mode, topK) {
+    nonnegative(pool, "pool");
+    const passing = scores.filter((s) => s.passes).sort((a, b) => b.score - a.score);
+    if (passing.length === 0)
+        return [];
+    let weights;
+    if (mode === AllocationMode.WinnerTakesAll) {
+        const maxScore = passing[0].score;
+        const winners = passing.filter((s) => s.score === maxScore);
+        const w = 1 / winners.length;
+        weights = winners.map((s) => ({ submissionIndex: s.submissionIndex, weight: w }));
+    }
+    else if (mode === AllocationMode.TopK) {
+        const k = topK ?? 1;
+        const selected = passing.slice(0, k);
+        if (selected.length < k) {
+            const w = 1 / selected.length;
+            weights = selected.map((s) => ({ submissionIndex: s.submissionIndex, weight: w }));
+        }
+        else {
+            const lastScore = selected[selected.length - 1].score;
+            const beforeLast = selected.filter((s) => s.score > lastScore);
+            const tied = passing.filter((s) => s.score === lastScore);
+            const remainingSlots = k - beforeLast.length;
+            const wBefore = 1 / k;
+            const wTied = remainingSlots / (k * tied.length);
+            weights = [
+                ...beforeLast.map((s) => ({ submissionIndex: s.submissionIndex, weight: wBefore })),
+                ...tied.map((s) => ({ submissionIndex: s.submissionIndex, weight: wTied })),
+            ];
+        }
+    }
+    else {
+        const totalScore = passing.reduce((sum, s) => sum + s.score, 0);
+        if (totalScore === 0) {
+            const w = 1 / passing.length;
+            weights = passing.map((s) => ({ submissionIndex: s.submissionIndex, weight: w }));
+        }
+        else {
+            weights = passing.map((s) => ({
+                submissionIndex: s.submissionIndex,
+                weight: s.score / totalScore,
+            }));
+        }
+    }
+    let allocated = 0n;
+    const results = weights.map((w, i) => {
+        const amount = i === weights.length - 1
+            ? pool - allocated
+            : (pool * BigInt(Math.floor(w.weight * 1_000_000_000))) / 1000000000n;
+        allocated += amount;
+        return { submissionIndex: w.submissionIndex, weight: w.weight, amount };
+    });
+    return results;
+}
+/**
+ * V4 executor allocation. Every valid, non-junk result participates and receives a
+ * score-proportional share; the final item absorbs integer division dust.
+ */
+export function allocateProRataExecutorPool(pool, scores) {
+    nonnegative(pool, "pool");
+    const eligible = scores
+        .filter(({ rewardEligible }) => rewardEligible)
+        .sort((left, right) => right.score - left.score || left.submissionIndex - right.submissionIndex);
+    if (eligible.length === 0)
+        return [];
+    const scaled = eligible.map((entry) => ({
+        ...entry,
+        units: BigInt(Math.max(1, Math.round(entry.score * 1_000_000))),
+    }));
+    const participantCount = BigInt(scaled.length);
+    if (pool < participantCount)
+        return [];
+    const distributable = pool - participantCount;
+    const totalUnits = scaled.reduce((sum, entry) => sum + entry.units, 0n);
+    let distributed = 0n;
+    return scaled.map((entry, index) => {
+        const proportional = index === scaled.length - 1
+            ? distributable - distributed
+            : (distributable * entry.units) / totalUnits;
+        distributed += proportional;
+        return {
+            submissionIndex: entry.submissionIndex,
+            weight: Number(entry.units) / Number(totalUnits),
+            amount: 1n + proportional,
+        };
+    });
+}
+// ---------------------------------------------------------------------------
+// Vesting (§4.10)
+// ---------------------------------------------------------------------------
+export function vestingSchedule(amount, acceptedAtSeconds, params) {
+    nonnegative(amount, "amount");
+    if (!Number.isInteger(acceptedAtSeconds) || acceptedAtSeconds < 0)
+        throw new RangeError("acceptedAtSeconds must be a nonneg integer");
+    const t0Bps = parameter(params, "vestingT0Bps");
+    const t1Bps = parameter(params, "vestingT1Bps");
+    const t0 = bpsDown(amount, t0Bps);
+    const t1 = bpsDown(amount, t1Bps);
+    const t2 = amount - t0 - t1;
+    return [
+        { amount: t0, releaseAtSeconds: acceptedAtSeconds },
+        {
+            amount: t1,
+            releaseAtSeconds: acceptedAtSeconds + parameter(params, "vestingT1Days") * SECONDS_PER_DAY,
+        },
+        {
+            amount: t2,
+            releaseAtSeconds: acceptedAtSeconds + parameter(params, "vestingT2Days") * SECONDS_PER_DAY,
+        },
+    ];
+}
+/** Split an arbitrary emission amount by frozen (or params) bps; arb is remainder. */
+export function splitEmission(amount, params) {
+    nonnegative(amount, "amount");
+    const platform = bpsDown(amount, parameter(params, "emissionPlatformBps"));
+    const executor = bpsDown(amount, parameter(params, "emissionExecBps"));
+    const tester = bpsDown(amount, parameter(params, "emissionTestBps"));
+    const arbitrator = amount - platform - executor - tester;
+    return { platform, executor, tester, arbitrator, total: amount };
+}
+/**
+ * Task share of an hour's executor emission, proportional to fee weight.
+ * `P_i = hourExec · fee / Σ fee` (floor). Window-second weighting is applied by the caller.
+ */
+export function executorPoolShare(hourExec, taskFeeWei, totalRunningFeesWei) {
+    nonnegative(hourExec, "hourExec");
+    nonnegative(taskFeeWei, "taskFeeWei");
+    nonnegative(totalRunningFeesWei, "totalRunningFeesWei");
+    if (totalRunningFeesWei === 0n || taskFeeWei === 0n)
+        return 0n;
+    return (hourExec * taskFeeWei) / totalRunningFeesWei;
+}
+/**
+ * Seat share of an hour's tester emission, proportional to seat weight.
+ * `T_s = hourTest · seatWeight / Σ seatWeight` (floor).
+ */
+export function testerSeatShare(hourTest, seatWeight, totalSeatWeight) {
+    nonnegative(hourTest, "hourTest");
+    nonnegative(seatWeight, "seatWeight");
+    nonnegative(totalSeatWeight, "totalSeatWeight");
+    if (totalSeatWeight === 0n || seatWeight === 0n)
+        return 0n;
+    return (hourTest * seatWeight) / totalSeatWeight;
+}
+/**
+ * Allocate a task executor pool by score using largest-remainder method (§4.4 / §4.7.1).
+ * Eligible set E: rewardEligible submissions. Empty E → empty allocation (caller burns pool).
+ */
+export function allocateByScore(pool, scores) {
+    nonnegative(pool, "pool");
+    const set = scores
+        .filter(({ rewardEligible }) => rewardEligible)
+        .sort((a, b) => b.score - a.score || a.submissionIndex - b.submissionIndex);
+    if (set.length === 0)
+        return [];
+    const totalScore = set.reduce((sum, entry) => sum + entry.score, 0);
+    if (totalScore <= 0) {
+        const even = pool / BigInt(set.length);
+        let distributed = 0n;
+        return set.map((entry, index) => {
+            const amount = index === set.length - 1 ? pool - distributed : even;
+            distributed += amount;
+            return { submissionIndex: entry.submissionIndex, weight: 1 / set.length, amount };
+        });
+    }
+    // Largest-remainder: floor shares then distribute remainder by fractional part.
+    const SCALE = 1000000n;
+    const units = set.map((entry) => ({
+        ...entry,
+        units: BigInt(Math.max(0, Math.round(entry.score * Number(SCALE)))),
+    }));
+    const totalUnits = units.reduce((sum, entry) => sum + entry.units, 0n);
+    if (totalUnits === 0n)
+        return [];
+    const floors = units.map((entry) => {
+        const raw = (pool * entry.units) / totalUnits;
+        const remainder = (pool * entry.units) % totalUnits;
+        return { ...entry, amount: raw, remainder, weight: Number(entry.units) / Number(totalUnits) };
+    });
+    let remaining = pool - floors.reduce((sum, entry) => sum + entry.amount, 0n);
+    for (const entry of floors
+        .slice()
+        .sort((a, b) => b.remainder > a.remainder
+        ? 1
+        : b.remainder < a.remainder
+            ? -1
+            : a.submissionIndex - b.submissionIndex)) {
+        if (remaining <= 0n)
+            break;
+        entry.amount += 1n;
+        remaining -= 1n;
+    }
+    return floors.map(({ submissionIndex, weight, amount }) => ({ submissionIndex, weight, amount }));
+}
+/** Vesting tranches for executor mining share (§4.10): 60% / 25% / 15% at T0 / +7d / +30d. */
+export function vestingTranches(amount, t0Seconds, params) {
+    return vestingSchedule(amount, t0Seconds, params);
+}
+/**
+ * Arbitrator weight (§4.7.3):
+ * min(stake, cap) × responseRate + Σ arbitratorMinStake × arbCaseBonusBps[tier] / 10000
+ * responseRateBps is 0–10000.
+ */
+export function computeArbitratorWeight(stakeWei, responseRateBps, activeSeats, params) {
+    nonnegative(stakeWei, "stakeWei");
+    if (!Number.isInteger(responseRateBps) || responseRateBps < 0 || responseRateBps > BPS) {
+        throw new RangeError("responseRateBps must be an integer in [0, 10000]");
+    }
+    const cap = agtToWei(parameter(params, "arbitratorWeightCapAgt"));
+    const capped = stakeWei < cap ? stakeWei : cap;
+    const base = (capped * BigInt(responseRateBps)) / BigInt(BPS);
+    const minStake = agtToWei(parameter(params, "arbitratorMinStakeAgt"));
+    let bonus = 0n;
+    for (const seat of activeSeats) {
+        const bps = parameter(params, `arbCaseBonusBps.${seat.tier}`);
+        bonus += bpsDown(minStake, bps);
+    }
+    return base + bonus;
+}
+export function computeTaskDailyEmission(taskBilledToday, totalBilledToday, dailyEmission, taskCumulativeEmission, taskCumulativeDeduction, params) {
+    nonnegative(taskBilledToday, "taskBilledToday");
+    nonnegative(totalBilledToday, "totalBilledToday");
+    nonnegative(dailyEmission, "dailyEmission");
+    nonnegative(taskCumulativeEmission, "taskCumulativeEmission");
+    nonnegative(taskCumulativeDeduction, "taskCumulativeDeduction");
+    const rhoBps = 8000;
+    const uBps = parameter(params, "unrecoverableCostBps");
+    const rho = rhoBps / BPS;
+    const u = uBps / BPS;
+    if (totalBilledToday === 0n) {
+        return {
+            taskBilled: taskBilledToday,
+            totalBilled: totalBilledToday,
+            dailyEmission,
+            rho,
+            u,
+            taskEmission: 0n,
+            capped: false,
+        };
+    }
+    const rateNumerator = dailyEmission;
+    const rateDenominator = totalBilledToday;
+    const rhoU = BigInt(Math.floor(rho * u * BPS));
+    const maxRate = rhoU;
+    let rate;
+    if (rateNumerator * BigInt(BPS) <= maxRate * rateDenominator) {
+        rate = rateNumerator;
+    }
+    else {
+        rate = (maxRate * rateDenominator) / BigInt(BPS);
+    }
+    let taskEm = (rate * taskBilledToday) / rateDenominator;
+    const hardCap = bpsDown(taskCumulativeDeduction, Math.floor(rho * u * BPS));
+    let capped = false;
+    if (taskCumulativeEmission + taskEm > hardCap) {
+        taskEm = hardCap > taskCumulativeEmission ? hardCap - taskCumulativeEmission : 0n;
+        capped = true;
+    }
+    return {
+        taskBilled: taskBilledToday,
+        totalBilled: totalBilledToday,
+        dailyEmission,
+        rho,
+        u,
+        taskEmission: taskEm,
+        capped,
+    };
+}
+// ---------------------------------------------------------------------------
+// Escalation (§3.4)
+// ---------------------------------------------------------------------------
+export function computeEscalationStep(runDays, params) {
+    const pctBps = parameter(params, "escalationStepPctBps");
+    const minHours = parameter(params, "escalationStepMinHours");
+    const stepHours = Math.max(minHours, (runDays * 24 * pctBps) / BPS);
+    return stepHours * 3600;
+}
+export function computeCurrentTier(startTier, maxTier, publishedAtSeconds, nowSeconds, escalationStepSeconds) {
+    if (escalationStepSeconds <= 0)
+        throw new RangeError("step must be positive");
+    const elapsed = nowSeconds - publishedAtSeconds;
+    if (elapsed < 0)
+        return startTier;
+    const steps = Math.floor(elapsed / escalationStepSeconds);
+    const rank = Math.min(tierRank[startTier] + steps, tierRank[maxTier]);
+    return tiers[rank - 1];
+}
+export function computeEarliestSubmitSeconds(runDays, params) {
+    const pctBps = parameter(params, "earliestSubmitPctBps");
+    const hours = (runDays * 24 * pctBps) / BPS;
+    const minH = parameter(params, "earliestSubmitMinHours");
+    const maxH = parameter(params, "earliestSubmitMaxHours");
+    return Math.max(minH, Math.min(maxH, hours)) * 3600;
+}
+// ---------------------------------------------------------------------------
+// Publisher stake (§5.2)
+// ---------------------------------------------------------------------------
+/** Amounts in wei. Mirrors PublisherStaking.reserve: base + ⌈β·(in-flight + next)⌉, and the balance must cover the reserve. */
+export function checkPublisherStake(input, params) {
+    nonnegative(input.actualStake, "actualStake");
+    nonnegative(input.inFlightReserves, "inFlightReserves");
+    nonnegative(input.nextReserve, "nextReserve");
+    const beta = BigInt(parameter(params, "publisherExposureBps"));
+    const exposure = input.inFlightReserves + input.nextReserve;
+    const minStake = agtToWei(parameter(params, "publisherBaseStakeAgt")) +
+        (exposure * beta + BigInt(BPS) - 1n) / BigInt(BPS);
+    const required = minStake > input.nextReserve ? minStake : input.nextReserve;
+    return { required, available: input.actualStake, ok: input.actualStake >= required };
+}
+/** Fixed role threshold in wei; matches ValidatorStaking.minimumStake(role). */
+export function validatorRoleMinimum(role, params) {
+    return agtToWei(parameter(params, role === "TESTER" ? "testerMinStakeAgt" : "arbitratorMinStakeAgt"));
+}
+/** Roles the stake currently qualifies for; matches ValidatorStaking.meetsMinimum (ignoring exit/ban). */
+export function qualifiedValidatorRoles(stake, params) {
+    nonnegative(stake, "stake");
+    if (stake === 0n)
+        return [];
+    const roles = [];
+    if (stake >= validatorRoleMinimum("TESTER", params))
+        roles.push("TESTER");
+    if (stake >= validatorRoleMinimum("ARBITRATOR", params))
+        roles.push("ARBITRATOR");
+    return roles;
+}
+/** Linear draw weight before response/activity factors: min(stake, role cap). */
+export function validatorDrawWeight(stake, role, params) {
+    nonnegative(stake, "stake");
+    const cap = agtToWei(parameter(params, role === "TESTER" ? "testerWeightCapAgt" : "arbitratorWeightCapAgt"));
+    return stake < cap ? stake : cap;
+}
+/** §7.6 missed report: min(multiple × reward, stakeCapBps × stake), all wei. */
+export function computeTesterMissReportSlash(testerReward, testerStake, params) {
+    nonnegative(testerReward, "testerReward");
+    nonnegative(testerStake, "testerStake");
+    const byReward = testerReward * BigInt(parameter(params, "testerMissReportSlashMultiple"));
+    const byStake = bpsDown(testerStake, parameter(params, "testerSlashStakeCapBps"));
+    return byReward < byStake ? byReward : byStake;
+}
+// ---------------------------------------------------------------------------
+// Arbitration capacity (03-STAKING-PENALTY-SPEC §5)
+// ---------------------------------------------------------------------------
+/** Largest dispute a task can produce: the executor pool share of its reserve (wei). */
+export function computeDisputeBound(reserve, params) {
+    nonnegative(reserve, "reserve");
+    return bpsDown(reserve, parameter(params, "deductionExecBps"));
+}
+/** Matches CourtRules.maxDisputeValue: fallback ceiling below the pool minimum, else threshold × mode multiplier. */
+export function computeMaxDisputeValue(pool, params) {
+    if (pool.eligibleArbitrators < parameter(params, "arbMinimumPoolSize")) {
+        return agtToWei(parameter(params, "arbFallbackMaxDisputeValueAgt"));
+    }
+    const multiplier = parameter(params, pool.fullScale ? "arbExposureMultiplierBps.Full" : "arbExposureMultiplierBps.Degraded");
+    return bpsDown(validatorRoleMinimum("ARBITRATOR", params), multiplier);
+}
+// ---------------------------------------------------------------------------
+// Arbitration panel (§7.1)
+// ---------------------------------------------------------------------------
+export function arbitrationPanel(eligibleArbitrators, round, params) {
+    if (!Number.isInteger(eligibleArbitrators) || eligibleArbitrators < 0)
+        throw new RangeError("eligibleArbitrators must be nonnegative");
+    if (eligibleArbitrators < parameter(params, "arbMinimumPoolSize")) {
+        return { enabled: false, panelSize: 0, majority: 0, minReveal: 0 };
+    }
+    const full = eligibleArbitrators >= parameter(params, "arbFullPanelThreshold");
+    const panelSize = (full
+        ? round === ArbitrationRound.First
+            ? parameter(params, "arbPanelSize.FullFirst")
+            : parameter(params, "arbPanelSize.FullFinal")
+        : round === ArbitrationRound.First
+            ? parameter(params, "arbPanelSize.DegradedFirst")
+            : parameter(params, "arbPanelSize.DegradedFinal"));
+    return {
+        enabled: true,
+        panelSize,
+        majority: Math.floor(panelSize / 2) + 1,
+        minReveal: Math.ceil((parameter(params, "arbMinRevealBps") * panelSize) / BPS),
+    };
+}
+export function t1FallbackPanel(params) {
+    return {
+        panelSize: parameter(params, "arbFallbackTesterCount"),
+        approvalCount: parameter(params, "arbFallbackApprovalCount"),
+    };
+}
+// ---------------------------------------------------------------------------
+// Case fee & bond
+// ---------------------------------------------------------------------------
+/** Dispute value in wei → case fee in wei; matches ArbitrationCourt.quoteCaseFee. */
+export function computeCaseFee(disputeValue, params) {
+    const proportional = bpsDown(disputeValue, parameter(params, "caseFeeBps"));
+    const minimum = agtToWei(parameter(params, "caseFeeMinAgt"));
+    return proportional > minimum ? proportional : minimum;
+}
+/** Appeal bond in wei: caseFee × appealBondMultiplierBps / 10000; matches ArbitrationCourt.appealBondOf. */
+export function computeAppealBond(caseFee, params) {
+    nonnegative(caseFee, "caseFee");
+    return bpsDown(caseFee, parameter(params, "appealBondMultiplierBps"));
+}
+/**
+ * Economic model v3 appeal fee (§7.3): min(appealFeeBps · F_t* / 10000, appealFeeCapAgt).
+ * Charged per appealed submission; paid entirely to revealed arbitrators.
+ */
+export function computeAppealFee(lockedTier, params, fees) {
+    const proportional = bpsDown(dailyFee(lockedTier, params, fees), parameter(params, "appealFeeBps"));
+    const cap = agtToWei(parameter(params, "appealFeeCapAgt"));
+    return proportional < cap ? proportional : cap;
+}
+/** Final appeal fee is 2× the first-round appeal fee. */
+export function computeFinalAppealFee(lockedTier, params, fees) {
+    return computeAppealFee(lockedTier, params, fees) * 2n;
+}
+export function computeCaseLock(disputeValue, validatorStake, params) {
+    const proportional = bpsDown(disputeValue, parameter(params, "caseLockBps"));
+    const minimum = agtToWei(parameter(params, "caseLockMinAgt"));
+    const capped = bpsDown(validatorStake, parameter(params, "caseLockStakeCapBps"));
+    const desired = proportional > minimum ? proportional : minimum;
+    return desired < capped ? desired : capped;
+}
+/** The remainder after majority and winner shares goes to the platform treasury (nothing is burned). */
+export function splitCaseFee(caseFee, params) {
+    nonnegative(caseFee, "caseFee");
+    const majority = bpsDown(caseFee, parameter(params, "caseFeeMajorityShareBps"));
+    const winner = bpsDown(caseFee, parameter(params, "caseFeeWinnerShareBps"));
+    return { majority, winner, platform: caseFee - majority - winner };
+}
+/**
+ * §7.3 overturn: the first-round majority's confiscated locks `Z` pay the challenger
+ * min(challengerRewardMultiple × R, Z) with R = caseFee × majority share ÷ final majority count;
+ * the rest splits platform / righteous jurors. Matches ArbitrationSettlement._slashOverturned.
+ */
+export function splitOverturnPenalty(confiscated, caseFee, finalMajorityCount, params) {
+    nonnegative(confiscated, "confiscated");
+    nonnegative(caseFee, "caseFee");
+    if (!Number.isInteger(finalMajorityCount) || finalMajorityCount < 1)
+        throw new RangeError("finalMajorityCount must be positive");
+    const perSeat = bpsDown(caseFee, parameter(params, "caseFeeMajorityShareBps")) / BigInt(finalMajorityCount);
+    const multiple = perSeat * BigInt(parameter(params, "challengerRewardMultiple"));
+    const challenger = multiple < confiscated ? multiple : confiscated;
+    const rest = confiscated - challenger;
+    const platform = bpsDown(rest, parameter(params, "overturnPlatformShareBps"));
+    return { challenger, platform, righteous: rest - platform };
+}
+export function testerPairDecay(encounterCount, params) {
+    if (!Number.isInteger(encounterCount) || encounterCount < 1)
+        throw new RangeError("encounterCount must be positive");
+    const position = Math.min(encounterCount, 5);
+    return parameter(params, `testerPairDecayBps.${position}`);
+}
+// ---------------------------------------------------------------------------
+// Anti-wash proof (§4.8)
+// ---------------------------------------------------------------------------
+/** @deprecated Safety-coeff anti-wash gate removed with continuous emission; kept for callers. */
+export function antiWashCheck(params) {
+    const u = parameter(params, "unrecoverableCostBps");
+    return { unrecoverableBps: u, maxEmissionBps: 0, ok: true };
+}
+// ---------------------------------------------------------------------------
+// Draft check (§3.2)
+// ---------------------------------------------------------------------------
+export function checkDraft(draft, params) {
+    const results = [];
+    const required = [
+        "title",
+        "summary",
+        "template",
+        "deliverables",
+        "criteria",
+        "estimatedHours",
+        "startTier",
+        "maxTier",
+        "runDays",
+        "maxParticipants",
+        "passingThreshold",
+    ];
+    const missing = required.filter((name) => draft.fields[name].value === null || draft.fields[name].confirmation !== "confirmed");
+    results.push({
+        id: "draft.completeness",
+        level: missing.length === 0 ? "ok" : "block",
+        message: missing.length === 0
+            ? "Required fields are confirmed"
+            : `Unconfirmed fields: ${missing.join(", ")}`,
+        fields: [...missing],
+    });
+    const draftCriteria = draft.fields.criteria.value;
+    const criteria = draftCriteria?.flatMap((criterion) => (criterion.value === null ? [] : [criterion.value])) ??
+        null;
+    const criteriaConfirmed = draftCriteria?.every((criterion) => criterion.value !== null && criterion.confirmation === "confirmed") ?? false;
+    results.push({
+        id: "criteria.confirmed",
+        level: criteriaConfirmed ? "ok" : "block",
+        message: criteriaConfirmed
+            ? "Every criterion is confirmed"
+            : "Every criterion must be present and confirmed",
+        fields: ["criteria"],
+    });
+    results.push(...checkSpecContent({
+        title: draft.fields.title.value,
+        summary: draft.fields.summary.value,
+        deliverables: draft.fields.deliverables.value,
+        constraints: draft.fields.constraints.value,
+        inputs: draft.fields.inputs.value,
+        criteria,
+    }));
+    const ruleFieldsValid = ["minimumTier", "cost", "allocationMode"].every((name) => draft.fields[name].source === "rule" && draft.fields[name].value !== null);
+    results.push({
+        id: "rule.sources",
+        level: ruleFieldsValid ? "ok" : "block",
+        message: ruleFieldsValid
+            ? "Derived fields are present and rule-sourced"
+            : "Derived fields must be present and rule-sourced",
+        fields: ["minimumTier", "cost", "allocationMode"],
+    });
+    const weights = criteria?.reduce((sum, criterion) => sum + criterion.weightBps, 0) ?? 0;
+    results.push({
+        id: "criteria.weights",
+        level: weights === 10_000 ? "ok" : "block",
+        message: weights === 10_000
+            ? "Criterion weights total 10000 bps"
+            : "Criterion weights must total 10000 bps",
+        fields: ["criteria"],
+    });
+    const idsUnique = criteria !== null && new Set(criteria.map(({ id }) => id)).size === criteria.length;
+    results.push({
+        id: "criteria.ids",
+        level: idsUnique ? "ok" : "block",
+        message: idsUnique ? "Criterion IDs are unique" : "Criterion IDs must be unique",
+        fields: ["criteria"],
+    });
+    if (criteria !== null &&
+        draft.fields.estimatedHours.value !== null &&
+        draft.fields.template.value !== null &&
+        draft.fields.startTier.value !== null &&
+        draft.fields.maxTier.value !== null &&
+        draft.fields.runDays.value !== null) {
+        const minimum = computeMinimumTier({
+            criteria,
+            estimatedHours: draft.fields.estimatedHours.value,
+            template: draft.fields.template.value,
+        });
+        const rangeMax = computeTierRangeMax(minimum, params);
+        const startTier = draft.fields.startTier.value;
+        const maxTierVal = draft.fields.maxTier.value;
+        const startOk = tierRank[startTier] >= tierRank[minimum] && tierRank[startTier] <= tierRank[rangeMax];
+        results.push({
+            id: "tier.start",
+            level: startOk ? "ok" : "block",
+            message: startOk
+                ? "Start tier is within rule range"
+                : `Start tier must be between ${minimum} and ${rangeMax}`,
+            fields: ["startTier"],
+            params: { minimum, rangeMax },
+        });
+        const maxOk = tierRank[maxTierVal] >= tierRank[startTier] && tierRank[maxTierVal] <= tierRank[rangeMax];
+        results.push({
+            id: "tier.max",
+            level: maxOk ? "ok" : "block",
+            message: maxOk
+                ? "Max tier is within rule range"
+                : `Max tier must be between ${startTier} and ${rangeMax}`,
+            fields: ["maxTier"],
+            params: { minimum: startTier, rangeMax },
+        });
+        const runDays = draft.fields.runDays.value;
+        const startRange = tierDaysRange(startTier, params);
+        const maxRange = tierDaysRange(maxTierVal, params);
+        const effectiveMin = Math.max(startRange.min, maxRange.min);
+        const effectiveMax = Math.min(startRange.max, maxRange.max);
+        const daysOk = runDays >= effectiveMin && runDays <= effectiveMax;
+        results.push({
+            id: "runDays.range",
+            level: daysOk ? "ok" : "block",
+            message: daysOk
+                ? "Run days within tier range"
+                : "Run days must be within both start and max tier ranges",
+            fields: ["runDays"],
+            params: {
+                minimum: String(effectiveMin),
+                maximum: String(effectiveMax),
+                startTier,
+                maxTier: maxTierVal,
+            },
+        });
+        const minimumTierOk = draft.fields.minimumTier.value === minimum;
+        results.push({
+            id: "tier.computed",
+            level: minimumTierOk ? "ok" : "block",
+            message: minimumTierOk
+                ? "Recorded minimum tier matches rule"
+                : "Recorded minimum tier is stale",
+            fields: ["minimumTier"],
+        });
+        const reserve = computeReserve(maxTierVal, runDays, params);
+        const expectedCost = {
+            reserve: reserve.toString(),
+            dailyFee: tierDailyFee(startTier, params).toString(),
+        };
+        const costOk = JSON.stringify(draft.fields.cost.value) === JSON.stringify(expectedCost);
+        results.push({
+            id: "cost.computed",
+            level: costOk ? "ok" : "block",
+            message: costOk ? "Recorded cost matches rule" : "Recorded cost is stale",
+            fields: ["cost"],
+        });
+        const limits = participantLimits(params);
+        const participantLimit = draft.fields.maxParticipants.value;
+        const unlimited = participantLimit === UNLIMITED_PARTICIPANTS;
+        const participantLimitOk = participantLimit !== null &&
+            Number.isInteger(participantLimit) &&
+            (unlimited || (participantLimit >= limits.min && participantLimit <= limits.max));
+        const heavy = unlimited || (participantLimit ?? 0) > limits.warning;
+        results.push({
+            id: "participants.range",
+            level: participantLimitOk ? (heavy ? "warn" : "ok") : "block",
+            message: participantLimitOk
+                ? unlimited
+                    ? "Participant cap is unlimited; testing cost grows with every delivery"
+                    : heavy
+                        ? `Participant cap ${participantLimit} may increase testing cost and latency`
+                        : `Participant cap ${participantLimit} is supported`
+                : `Participant cap must be ${UNLIMITED_PARTICIPANTS} (unlimited) or between ${limits.min} and ${limits.max}`,
+            fields: ["maxParticipants"],
+            params: {
+                default: String(limits.default),
+                warning: String(limits.warning),
+                maximum: String(limits.max),
+                unlimited: String(unlimited),
+            },
+        });
+    }
+    return results;
+}
+//# sourceMappingURL=index.js.map