npm - @treeseed/sdk - Versions diffs - 0.12.62 → 0.13.0-rc.2 - Mend

@treeseed/sdk 0.12.62 → 0.13.0-rc.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3212) hide show

package/dist/capacity.js DELETED Viewed

@@ -1,2331 +0,0 @@
-const ACTUAL_CREDIT_FORMULA_VERSION = "treeseed.actual-credits.v1";
-function finiteActualMetric(value) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return null;
-}
-function firstActualMetric(...values) {
-  for (const value of values) {
-    const next = finiteActualMetric(value);
-    if (next !== null) return next;
-  }
-  return null;
-}
-function objectActualValue(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function booleanActualFlag(value) {
-  return value === true || value === "true" || value === 1 || value === "1";
-}
-function roundActualCredits(value) {
-  if (!Number.isFinite(value) || value <= 0) return 0;
-  return Math.round(value * 100) / 100;
-}
-function roundUpCreditComponent(value) {
-  if (!Number.isFinite(value) || value <= 0) return 0;
-  return Math.ceil(value * 100) / 100;
-}
-function stringActualValue(value, fallback = "") {
-  return typeof value === "string" && value.trim() ? value.trim() : fallback;
-}
-function nativeUsageUnit(input) {
-  const native = objectActualValue(input);
-  const explicit = stringActualValue(native.nativeUnit, stringActualValue(native.native_unit));
-  if (explicit) return explicit;
-  if (firstActualMetric(native.wallMinutes, native.wall_minutes, native.durationMinutes, native.duration_minutes) !== null) return "wall_minute";
-  if (firstActualMetric(native.quotaMinutes, native.quota_minutes) !== null) return "quota_minute";
-  if (firstActualMetric(native.usd, native.costUsd, native.cost_usd) !== null) return "usd";
-  if (firstActualMetric(native.inputTokens, native.input_tokens, native.outputTokens, native.output_tokens) !== null) return "token";
-  return null;
-}
-function nativeUsageAmount(input, nativeUnit) {
-  const native = objectActualValue(input);
-  const unit = nativeUnit?.trim() || nativeUsageUnit(native);
-  if (!unit) return null;
-  if (unit === "wall_minute") {
-    return firstActualMetric(native.wallMinutes, native.wall_minutes, native.durationMinutes, native.duration_minutes);
-  }
-  if (unit === "quota_minute") {
-    return firstActualMetric(native.quotaMinutes, native.quota_minutes);
-  }
-  if (unit === "usd") {
-    return firstActualMetric(native.usd, native.costUsd, native.cost_usd);
-  }
-  if (unit === "token") {
-    const inputTokens = firstActualMetric(native.inputTokens, native.input_tokens) ?? 0;
-    const outputTokens = firstActualMetric(native.outputTokens, native.output_tokens) ?? 0;
-    const cachedInputTokens = firstActualMetric(native.cachedInputTokens, native.cached_input_tokens) ?? 0;
-    const total = Math.max(0, inputTokens + outputTokens - cachedInputTokens);
-    return total > 0 ? total : null;
-  }
-  return firstActualMetric(native.amount, native.value, native.nativeAmount, native.native_amount);
-}
-function conversionConfidence(input) {
-  if (input.completedSampleCount < 5) return "low";
-  if (input.completedSampleCount < 20) return "medium";
-  const p50 = Math.max(1, input.nativeUnitsPerCreditP50 ?? 1);
-  const spread = Math.sqrt(Math.max(0, input.ratioVariance)) / p50;
-  return spread <= 0.5 ? "high" : "medium";
-}
-function selectCreditConversionProfile(input) {
-  const taskSignature = input.taskSignature?.trim();
-  const executionProfileId = input.executionProfileId?.trim() || DEFAULT_EXECUTION_PROFILE_ID;
-  const executionProviderKind = input.executionProviderKind?.trim();
-  const nativeUnit = input.nativeUnit?.trim();
-  if (!taskSignature || !executionProviderKind || !nativeUnit) return null;
-  return (input.profiles ?? []).find(
-    (profile) => profile.taskSignature === taskSignature && (profile.executionProfileId || DEFAULT_EXECUTION_PROFILE_ID) === executionProfileId && profile.executionProviderKind === executionProviderKind && profile.nativeUnit === nativeUnit
-  ) ?? null;
-}
-function buildCreditConversionProfileFromActuals(input) {
-  const taskSignature = input.taskSignature;
-  const executionProfileId = input.executionProfileId?.trim() || DEFAULT_EXECUTION_PROFILE_ID;
-  const executionProviderKind = input.executionProviderKind.trim();
-  const nativeUnit = input.nativeUnit.trim();
-  const matching = input.actuals.filter(
-    (actual) => actual.taskSignature === taskSignature && (actual.executionProfileId || DEFAULT_EXECUTION_PROFILE_ID) === executionProfileId
-  );
-  const completed = matching.filter((actual) => !isInterruptedUsageActual(actual));
-  const interrupted = matching.filter((actual) => isInterruptedUsageActual(actual));
-  const completedRatios = completed.map((actual) => {
-    const amount = nativeUsageAmount(actual.nativeUsage, nativeUnit);
-    const credits = finiteOrParsedNumber(actual.actualCredits);
-    if (amount === null || amount <= 0 || credits === null || credits <= 0) return null;
-    return {
-      nativeUnitsPerCredit: amount / credits,
-      creditsPerNativeUnit: credits / amount,
-      actualCredits: credits,
-      nativeAmount: amount
-    };
-  }).filter((value) => value !== null);
-  const ratioP50 = estimateLearningPercentile(completedRatios.map((sample) => sample.nativeUnitsPerCredit), 50);
-  const ratioP90 = estimateLearningPercentile(completedRatios.map((sample) => sample.nativeUnitsPerCredit), 90);
-  const ratioVariance = estimateLearningVariance(completedRatios.map((sample) => sample.nativeUnitsPerCredit));
-  const outlierLimit = ratioP90 === null ? null : Math.max(ratioP90 * 1.5, (ratioP50 ?? ratioP90) + Math.sqrt(ratioVariance));
-  const filteredRatios = outlierLimit === null ? completedRatios : completedRatios.filter((sample) => sample.nativeUnitsPerCredit <= outlierLimit);
-  const dates = matching.map((actual) => actual.createdAt).filter((value) => typeof value === "string" && value.length > 0).sort();
-  const partialCredits = interrupted.reduce((total, actual) => total + Math.max(0, finiteOrParsedNumber(actual.actualCredits) ?? 0), 0);
-  const partialNativeAmount = interrupted.reduce((total, actual) => total + Math.max(0, nativeUsageAmount(actual.nativeUsage, nativeUnit) ?? 0), 0);
-  const updatedAt = input.now instanceof Date ? input.now.toISOString() : typeof input.now === "string" ? input.now : (/* @__PURE__ */ new Date()).toISOString();
-  const nativeUnitsPerCreditP50 = estimateLearningPercentile(filteredRatios.map((sample) => sample.nativeUnitsPerCredit), 50);
-  const nativeUnitsPerCreditP90 = estimateLearningPercentile(filteredRatios.map((sample) => sample.nativeUnitsPerCredit), 90);
-  return {
-    id: input.id ?? `${taskSignature}:${executionProfileId}:${executionProviderKind}:${nativeUnit}`,
-    taskSignature,
-    executionProfileId,
-    executionProviderKind,
-    nativeUnit,
-    sampleCount: matching.length,
-    completedSampleCount: completedRatios.length,
-    interruptedSampleCount: interrupted.length,
-    nativeUnitsPerCreditP50,
-    nativeUnitsPerCreditP90,
-    creditsPerNativeUnitP50: estimateLearningPercentile(filteredRatios.map((sample) => sample.creditsPerNativeUnit), 50),
-    creditsPerNativeUnitP90: estimateLearningPercentile(filteredRatios.map((sample) => sample.creditsPerNativeUnit), 90),
-    actualCreditsP50: estimateLearningPercentile(filteredRatios.map((sample) => sample.actualCredits), 50),
-    actualCreditsP90: estimateLearningPercentile(filteredRatios.map((sample) => sample.actualCredits), 90),
-    confidence: conversionConfidence({
-      completedSampleCount: completedRatios.length,
-      ratioVariance,
-      nativeUnitsPerCreditP50
-    }),
-    formulaVersion: input.formulaVersion ?? ACTUAL_CREDIT_FORMULA_VERSION,
-    metadata: {
-      outlierCount: outlierLimit === null ? 0 : completedRatios.length - filteredRatios.length,
-      ratioVariance,
-      partialCredits,
-      partialNativeAmount,
-      firstSampleAt: dates[0] ?? null,
-      lastSampleAt: dates.at(-1) ?? null
-    },
-    updatedAt
-  };
-}
-function derivedConfidenceRank(value) {
-  if (value === "high") return 3;
-  if (value === "medium") return 2;
-  return 1;
-}
-function derivedConfidenceFromRank(rank) {
-  if (rank >= 3) return "high";
-  if (rank >= 2) return "medium";
-  return "low";
-}
-function lowerDerivedConfidence(value) {
-  return derivedConfidenceFromRank(Math.min(derivedConfidenceRank(value), 2));
-}
-function nativeRemainingAmount(input, nativeUnit) {
-  return nativeUsageAmount({
-    ...input,
-    nativeUnit
-  }, nativeUnit);
-}
-function reservationNativeDebit(reservation, executionProvider, nativeUnit) {
-  if (!["reserved", "consuming", "consumed", "failed", "overran_pending_approval"].includes(reservation.state)) {
-    return { reserved: 0, consumed: 0, inferred: false };
-  }
-  const metadata = readRecord(reservation.metadata);
-  const metadataNativeUnit = typeof metadata.nativeUnit === "string" && metadata.nativeUnit.trim() ? metadata.nativeUnit.trim() : typeof metadata.native_unit === "string" && metadata.native_unit.trim() ? metadata.native_unit.trim() : null;
-  const directReserved = finiteOrParsedNumber(reservation.reservedNativeAmount);
-  const directConsumed = finiteOrParsedNumber(reservation.consumedNativeAmount);
-  if ((reservation.nativeUnit ?? null) === nativeUnit && (directReserved !== null || directConsumed !== null)) {
-    return {
-      reserved: ["reserved", "consuming"].includes(reservation.state) ? Math.max(directReserved ?? 0, directConsumed ?? 0) : 0,
-      consumed: ["consumed", "failed", "overran_pending_approval"].includes(reservation.state) ? Math.max(directConsumed ?? 0, 0) : 0,
-      inferred: false
-    };
-  }
-  const metadataReserved = finiteOrParsedNumber(metadata.reservedNativeAmount) ?? finiteOrParsedNumber(metadata.reserved_native_amount);
-  const metadataConsumed = finiteOrParsedNumber(metadata.consumedNativeAmount) ?? finiteOrParsedNumber(metadata.consumed_native_amount);
-  if (metadataNativeUnit === nativeUnit && (metadataReserved !== null || metadataConsumed !== null)) {
-    return {
-      reserved: ["reserved", "consuming"].includes(reservation.state) ? Math.max(metadataReserved ?? 0, metadataConsumed ?? 0) : 0,
-      consumed: ["consumed", "failed", "overran_pending_approval"].includes(reservation.state) ? Math.max(metadataConsumed ?? 0, 0) : 0,
-      inferred: true
-    };
-  }
-  if (nativeUnit === "usd" && reservation.reservedUsd !== null) {
-    return {
-      reserved: ["reserved", "consuming"].includes(reservation.state) ? Math.max(reservation.reservedUsd ?? 0, reservation.consumedUsd ?? 0) : 0,
-      consumed: ["consumed", "failed", "overran_pending_approval"].includes(reservation.state) ? Math.max(reservation.consumedUsd ?? 0, 0) : 0,
-      inferred: true
-    };
-  }
-  if (reservation.reservedProviderUnits !== null && executionProvider.nativeUnit === nativeUnit) {
-    return {
-      reserved: ["reserved", "consuming"].includes(reservation.state) ? Math.max(reservation.reservedProviderUnits ?? 0, reservation.consumedProviderUnits ?? 0) : 0,
-      consumed: ["consumed", "failed", "overran_pending_approval"].includes(reservation.state) ? Math.max(reservation.consumedProviderUnits ?? 0, 0) : 0,
-      inferred: true
-    };
-  }
-  return { reserved: 0, consumed: 0, inferred: false };
-}
-function roundDownCredits(value) {
-  if (!Number.isFinite(value) || value <= 0) return 0;
-  return Math.floor(value * 100) / 100;
-}
-function deriveAvailableCredits(input) {
-  const executionProvider = input.executionProvider;
-  const nativeUnit = input.nativeUnit?.trim() || input.nativeLimit?.nativeUnit || executionProvider.nativeUnit;
-  const reasons = [];
-  const configuredNativeLimit = finiteOrParsedNumber(input.nativeLimit?.limitAmount);
-  const observationRemaining = nativeRemainingAmount(readRecord(input.latestObservation?.nativeRemaining), nativeUnit);
-  let nativeBase = null;
-  let nativeRemainingSource = "unknown";
-  if (observationRemaining !== null) {
-    nativeBase = Math.max(0, observationRemaining);
-    nativeRemainingSource = "observation";
-    reasons.push("observation_remaining");
-  } else if (configuredNativeLimit !== null) {
-    nativeBase = Math.max(0, configuredNativeLimit);
-    nativeRemainingSource = "configured_limit";
-    reasons.push(executionProvider.quotaVisibility === "opaque" ? "opaque_limit_fallback" : "configured_limit");
-  } else {
-    reasons.push("missing_native_limit");
-  }
-  const scopedReservations = (input.activeReservations ?? []).filter(
-    (reservation) => reservation.executionProviderId ? reservation.executionProviderId === executionProvider.id : reservation.capacityProviderId === executionProvider.capacityProviderId
-  );
-  let activeReservedNativeAmount = 0;
-  let activeConsumedNativeAmount = 0;
-  let inferredReservationCount = 0;
-  for (const reservation of scopedReservations) {
-    const debit = reservationNativeDebit(reservation, executionProvider, nativeUnit);
-    activeReservedNativeAmount += debit.reserved;
-    activeConsumedNativeAmount += debit.consumed;
-    if (debit.inferred && (debit.reserved > 0 || debit.consumed > 0)) inferredReservationCount += 1;
-  }
-  if (activeReservedNativeAmount > 0) reasons.push("active_native_reservations");
-  if (inferredReservationCount > 0) reasons.push("inferred_legacy_native_reservations");
-  const reserveBufferPercent = Math.max(0, finiteOrParsedNumber(input.nativeLimit?.reserveBufferPercent) ?? 0);
-  const reserveBufferNativeAmount = configuredNativeLimit === null ? 0 : configuredNativeLimit * reserveBufferPercent / 100;
-  if (reserveBufferNativeAmount > 0) reasons.push("reserve_buffer");
-  const availableNativeAmount = Math.max(0, (nativeBase ?? 0) - activeReservedNativeAmount - reserveBufferNativeAmount);
-  const profile = input.conversionProfile ?? null;
-  let nativeUnitsPerCredit = profile?.nativeUnitsPerCreditP90 ?? null;
-  let confidence = profile?.confidence ?? "low";
-  if (nativeUnitsPerCredit !== null && nativeUnitsPerCredit > 0) {
-    reasons.push("p90_conversion_profile");
-  } else if (profile?.nativeUnitsPerCreditP50 !== null && profile?.nativeUnitsPerCreditP50 !== void 0 && profile.nativeUnitsPerCreditP50 > 0) {
-    nativeUnitsPerCredit = profile.nativeUnitsPerCreditP50;
-    confidence = lowerDerivedConfidence(profile.confidence);
-    reasons.push("p50_conversion_fallback");
-  } else {
-    reasons.push("missing_conversion_profile");
-  }
-  if (nativeRemainingSource === "unknown") confidence = "low";
-  const derivedAvailableCredits = nativeUnitsPerCredit !== null && nativeUnitsPerCredit > 0 ? roundDownCredits(availableNativeAmount / nativeUnitsPerCredit) : null;
-  return {
-    executionProviderId: executionProvider.id,
-    capacityProviderId: executionProvider.capacityProviderId,
-    executionProviderKind: executionProvider.kind,
-    nativeUnit,
-    scope: input.scope ?? input.nativeLimit?.scope ?? null,
-    configuredNativeLimit,
-    observedNativeRemaining: observationRemaining,
-    nativeRemainingSource,
-    activeReservedNativeAmount,
-    activeConsumedNativeAmount,
-    reserveBufferPercent,
-    reserveBufferNativeAmount,
-    availableNativeAmount,
-    nativeUnitsPerCredit,
-    conversionProfileId: profile?.id ?? null,
-    conversionTaskSignature: profile?.taskSignature ?? null,
-    conversionConfidence: profile?.confidence ?? null,
-    derivedAvailableCredits,
-    confidence,
-    resetAt: input.latestObservation?.resetAt ?? input.nativeLimit?.resetAt ?? null,
-    reasons: [...new Set(reasons)],
-    metadata: {
-      quotaVisibility: executionProvider.quotaVisibility,
-      latestObservedAt: input.latestObservation?.observedAt ?? null,
-      conversionFormulaVersion: profile?.formulaVersion ?? null
-    }
-  };
-}
-function calculateActualCredits(input) {
-  const native = objectActualValue(input.nativeUsage);
-  const metadata = objectActualValue(native.metadata);
-  const wallMinutes = firstActualMetric(input.wallMinutes, native.wallMinutes, native.wall_minutes, native.durationMinutes, native.duration_minutes);
-  const quotaMinutes = firstActualMetric(input.quotaMinutes, native.quotaMinutes, native.quota_minutes);
-  const inputTokens = firstActualMetric(input.inputTokens, native.inputTokens, native.input_tokens);
-  const outputTokens = firstActualMetric(input.outputTokens, native.outputTokens, native.output_tokens);
-  const cachedInputTokens = firstActualMetric(input.cachedInputTokens, native.cachedInputTokens, native.cached_input_tokens);
-  const usd = firstActualMetric(input.actualUsd, native.usd, native.costUsd, native.cost_usd);
-  const filesOpened = firstActualMetric(input.filesOpened, native.filesOpened, native.files_opened);
-  const filesChanged = firstActualMetric(input.filesChanged, native.filesChanged, native.files_changed);
-  const diffLinesAdded = firstActualMetric(input.diffLinesAdded, native.diffLinesAdded, native.diff_lines_added);
-  const diffLinesRemoved = firstActualMetric(input.diffLinesRemoved, native.diffLinesRemoved, native.diff_lines_removed);
-  const testRuns = firstActualMetric(input.testRuns, native.testRuns, native.test_runs);
-  const retryCount = firstActualMetric(input.retryCount, native.retryCount, native.retry_count);
-  const nativeUnit = typeof native.nativeUnit === "string" ? native.nativeUnit : typeof native.native_unit === "string" ? native.native_unit : nativeUsageUnit(native) ?? (wallMinutes !== null ? "wall_minute" : quotaMinutes !== null ? "quota_minute" : usd !== null ? "usd" : Math.max(0, (inputTokens ?? 0) + (outputTokens ?? 0) - (cachedInputTokens ?? 0)) > 0 ? "token" : null);
-  const observedAt = typeof native.observedAt === "string" ? native.observedAt : typeof native.observed_at === "string" ? native.observed_at : null;
-  const partial = booleanActualFlag(native.partial) || booleanActualFlag(metadata.partial);
-  const interrupted = booleanActualFlag(native.interrupted) || booleanActualFlag(metadata.interrupted);
-  const legacyActualCredits = finiteActualMetric(input.legacyActualCredits);
-  const reservedCredits = finiteActualMetric(input.reservedCredits);
-  const components = {};
-  if (wallMinutes !== null && wallMinutes > 0) {
-    components.wallMinutes = Math.ceil(wallMinutes / 5);
-  } else if (quotaMinutes !== null && quotaMinutes > 0) {
-    components.quotaMinutes = Math.ceil(quotaMinutes / 5);
-  }
-  if (usd !== null && usd > 0) components.usd = roundUpCreditComponent(usd / 0.03);
-  const billableTokens = Math.max(0, (inputTokens ?? 0) + (outputTokens ?? 0) - (cachedInputTokens ?? 0));
-  if (billableTokens > 0) components.tokens = Math.ceil(billableTokens / 8e3);
-  if (filesChanged !== null && filesChanged > 0) components.filesChanged = Math.ceil(filesChanged) * 2;
-  if (testRuns !== null && testRuns > 0) components.testRuns = Math.ceil(testRuns);
-  if (retryCount !== null && retryCount > 0) components.retryCount = Math.ceil(retryCount) * 3;
-  const nativeUsage = {
-    ...native,
-    nativeUnit,
-    wallMinutes,
-    quotaMinutes,
-    inputTokens,
-    outputTokens,
-    cachedInputTokens,
-    usd,
-    filesOpened,
-    filesChanged,
-    diffLinesAdded,
-    diffLinesRemoved,
-    testRuns,
-    retryCount,
-    partial,
-    interrupted,
-    source: typeof native.source === "string" ? native.source : input.source ?? null,
-    observedAt,
-    metadata
-  };
-  const componentTotal = Object.values(components).reduce((total, value) => total + value, 0);
-  const conversionProfile = input.conversionProfile ?? null;
-  const conversionProfileNativeAmount = conversionProfile ? nativeUsageAmount(nativeUsage, conversionProfile.nativeUnit) : null;
-  const conversionProfileCredits = conversionProfileNativeAmount !== null && conversionProfileNativeAmount > 0 && conversionProfile.nativeUnitsPerCreditP50 !== null && conversionProfile.nativeUnitsPerCreditP50 > 0 ? roundActualCredits(conversionProfileNativeAmount / conversionProfile.nativeUnitsPerCreditP50) : null;
-  if (legacyActualCredits !== null && input.actualCreditsOverride === true) {
-    return {
-      actualCredits: roundActualCredits(legacyActualCredits),
-      formulaVersion: ACTUAL_CREDIT_FORMULA_VERSION,
-      source: "legacy_override",
-      nativeUsage,
-      components,
-      partial,
-      interrupted,
-      conversionProfileId: conversionProfile?.id ?? null,
-      conversionConfidence: conversionProfile?.confidence ?? null
-    };
-  }
-  if (conversionProfile?.confidence === "high" && conversionProfileCredits !== null) {
-    return {
-      actualCredits: conversionProfileCredits,
-      formulaVersion: ACTUAL_CREDIT_FORMULA_VERSION,
-      source: "conversion_profile",
-      nativeUsage,
-      components: {
-        ...components,
-        conversionProfile: conversionProfileCredits
-      },
-      partial,
-      interrupted,
-      conversionProfileId: conversionProfile.id ?? null,
-      conversionConfidence: conversionProfile.confidence
-    };
-  }
-  if (conversionProfile?.confidence === "medium" && conversionProfileCredits !== null && componentTotal > 0) {
-    return {
-      actualCredits: roundActualCredits((conversionProfileCredits + componentTotal) / 2),
-      formulaVersion: ACTUAL_CREDIT_FORMULA_VERSION,
-      source: "blended_conversion_profile",
-      nativeUsage,
-      components: {
-        ...components,
-        conversionProfile: conversionProfileCredits,
-        bootstrap: roundActualCredits(componentTotal)
-      },
-      partial,
-      interrupted,
-      conversionProfileId: conversionProfile.id ?? null,
-      conversionConfidence: conversionProfile.confidence
-    };
-  }
-  if (componentTotal > 0) {
-    return {
-      actualCredits: roundActualCredits(componentTotal),
-      formulaVersion: ACTUAL_CREDIT_FORMULA_VERSION,
-      source: "central_calculator",
-      nativeUsage,
-      components,
-      partial,
-      interrupted,
-      conversionProfileId: conversionProfile?.id ?? null,
-      conversionConfidence: conversionProfile?.confidence ?? null
-    };
-  }
-  if (legacyActualCredits !== null) {
-    return {
-      actualCredits: roundActualCredits(legacyActualCredits),
-      formulaVersion: ACTUAL_CREDIT_FORMULA_VERSION,
-      source: "legacy_fallback",
-      nativeUsage,
-      components,
-      partial,
-      interrupted,
-      conversionProfileId: conversionProfile?.id ?? null,
-      conversionConfidence: conversionProfile?.confidence ?? null
-    };
-  }
-  if (reservedCredits !== null) {
-    return {
-      actualCredits: roundActualCredits(reservedCredits),
-      formulaVersion: ACTUAL_CREDIT_FORMULA_VERSION,
-      source: "reserved_fallback",
-      nativeUsage,
-      components,
-      partial,
-      interrupted,
-      conversionProfileId: conversionProfile?.id ?? null,
-      conversionConfidence: conversionProfile?.confidence ?? null
-    };
-  }
-  return {
-    actualCredits: 0,
-    formulaVersion: ACTUAL_CREDIT_FORMULA_VERSION,
-    source: "zero_fallback",
-    nativeUsage,
-    components,
-    partial,
-    interrupted,
-    conversionProfileId: conversionProfile?.id ?? null,
-    conversionConfidence: conversionProfile?.confidence ?? null
-  };
-}
-const DEFAULT_EXECUTION_PROFILE_ID = "standard-code-model";
-function finiteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function finiteOrParsedNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number.parseFloat(value);
-    return Number.isFinite(parsed) ? parsed : null;
-  }
-  return null;
-}
-function stringValue(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-function positiveNumber(value, fallback) {
-  const parsed = finiteNumber(value);
-  return parsed !== null && parsed > 0 ? parsed : fallback;
-}
-function nonNegativeNumber(value, fallback) {
-  const parsed = finiteNumber(value);
-  return parsed !== null && parsed >= 0 ? parsed : fallback;
-}
-function scarcityPenalty(level) {
-  if (level === "high") return 35;
-  if (level === "medium") return 15;
-  return 0;
-}
-function metadataStatus(value) {
-  const status = value?.status;
-  return typeof status === "string" ? status : null;
-}
-function stringArray(value) {
-  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-function booleanValue(value) {
-  return typeof value === "boolean" ? value : null;
-}
-function numberValue(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function profileIdFrom(input) {
-  if (!input) return DEFAULT_EXECUTION_PROFILE_ID;
-  if (typeof input === "string") return input.trim() || DEFAULT_EXECUTION_PROFILE_ID;
-  return input.id?.trim() || DEFAULT_EXECUTION_PROFILE_ID;
-}
-function metadataFlag(metadata, key) {
-  return metadata?.[key] === true || metadata?.[key] === "true";
-}
-function numericActuals(values) {
-  return values.map((value) => finiteOrParsedNumber(value)).filter((value) => value !== null && value >= 0).sort((left, right) => left - right);
-}
-function estimateLearningPercentile(values, percentile) {
-  const sorted = numericActuals(values);
-  if (sorted.length === 0) return null;
-  const bounded = Math.min(100, Math.max(0, percentile));
-  const index = Math.ceil(bounded / 100 * sorted.length) - 1;
-  return sorted[Math.min(sorted.length - 1, Math.max(0, index))] ?? null;
-}
-function estimateLearningVariance(values) {
-  const samples = numericActuals(values);
-  if (samples.length <= 1) return 0;
-  const mean = samples.reduce((total, value) => total + value, 0) / samples.length;
-  return samples.reduce((total, value) => total + (value - mean) ** 2, 0) / samples.length;
-}
-function isInterruptedUsageActual(actual) {
-  const metadata = actual.metadata ?? {};
-  return metadataFlag(metadata, "interrupted") || metadataFlag(metadata, "partial");
-}
-function estimateProfileConfidenceScore(input) {
-  const sampleCount = Math.max(0, Math.floor(finiteOrParsedNumber(input.sampleCount) ?? 0));
-  const sampleScore = Math.min(1, sampleCount / 20);
-  const p50 = Math.max(1, finiteOrParsedNumber(input.creditsP50) ?? 1);
-  const variance = Math.max(0, finiteOrParsedNumber(input.creditsVariance) ?? 0);
-  const varianceScore = 1 / (1 + Math.sqrt(variance) / p50);
-  let ageScore = 1;
-  if (input.lastSampleAt) {
-    const now = input.now instanceof Date ? input.now : new Date(input.now ?? Date.now());
-    const last = new Date(input.lastSampleAt);
-    if (Number.isFinite(last.valueOf()) && Number.isFinite(now.valueOf())) {
-      const days = Math.max(0, (now.valueOf() - last.valueOf()) / 864e5);
-      ageScore = days > 90 ? 0.35 : days > 30 ? 0.7 : 1;
-    }
-  }
-  return Math.max(0, Math.min(1, sampleScore * varianceScore * ageScore));
-}
-function estimateConfidenceFromProfile(profile, now) {
-  if (!profile) return "medium";
-  const confidenceScore = finiteOrParsedNumber(profile.confidenceScore) ?? estimateProfileConfidenceScore({
-    sampleCount: profile.completedSampleCount ?? profile.sampleCount,
-    creditsVariance: profile.creditsVariance,
-    creditsP50: profile.creditsP50,
-    lastSampleAt: profile.lastSampleAt ?? profile.updatedAt,
-    now
-  });
-  if (confidenceScore >= 0.75) return "high";
-  if (confidenceScore >= 0.35) return "medium";
-  return "low";
-}
-function selectTaskEstimateProfile(input) {
-  const taskSignature = input.taskSignature?.trim();
-  if (!taskSignature) return null;
-  const executionProfileId = input.executionProfileId?.trim() || profileIdFrom(input.executionProfile);
-  const profiles = input.profiles ?? [];
-  return profiles.find(
-    (profile) => profile.taskSignature === taskSignature && (profile.executionProfileId || DEFAULT_EXECUTION_PROFILE_ID) === executionProfileId
-  ) ?? profiles.find(
-    (profile) => profile.taskSignature === taskSignature && (profile.executionProfileId || DEFAULT_EXECUTION_PROFILE_ID) === DEFAULT_EXECUTION_PROFILE_ID
-  ) ?? null;
-}
-function buildTaskEstimateProfileFromActuals(input) {
-  const taskSignature = input.taskSignature;
-  const executionProfileId = input.executionProfileId?.trim() || DEFAULT_EXECUTION_PROFILE_ID;
-  const matching = input.actuals.filter(
-    (actual) => actual.taskSignature === taskSignature && (actual.executionProfileId || DEFAULT_EXECUTION_PROFILE_ID) === executionProfileId
-  );
-  const completed = matching.filter((actual) => !isInterruptedUsageActual(actual));
-  const interrupted = matching.filter((actual) => isInterruptedUsageActual(actual));
-  const credits = completed.map((actual) => actual.actualCredits);
-  const creditsP50 = estimateLearningPercentile(credits, 50);
-  const creditsP90 = estimateLearningPercentile(credits, 90);
-  const creditsVariance = estimateLearningVariance(credits);
-  const outlierLimit = creditsP90 === null ? null : Math.max(creditsP90 * 1.5, (creditsP50 ?? creditsP90) + Math.sqrt(creditsVariance));
-  const lastCreatedAt = matching.map((actual) => actual.createdAt).filter((value) => typeof value === "string" && value.length > 0).sort();
-  const partialCredits = interrupted.reduce((total, actual) => total + Math.max(0, finiteOrParsedNumber(actual.actualCredits) ?? 0), 0);
-  const updatedAt = input.now instanceof Date ? input.now.toISOString() : typeof input.now === "string" ? input.now : (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    taskSignature,
-    executionProfileId,
-    sampleCount: matching.length,
-    completedSampleCount: completed.length,
-    interruptedSampleCount: interrupted.length,
-    inputTokensP50: estimateLearningPercentile(completed.map((actual) => actual.inputTokens), 50),
-    inputTokensP90: estimateLearningPercentile(completed.map((actual) => actual.inputTokens), 90),
-    outputTokensP50: estimateLearningPercentile(completed.map((actual) => actual.outputTokens), 50),
-    outputTokensP90: estimateLearningPercentile(completed.map((actual) => actual.outputTokens), 90),
-    quotaMinutesP50: estimateLearningPercentile(completed.map((actual) => actual.quotaMinutes), 50),
-    quotaMinutesP90: estimateLearningPercentile(completed.map((actual) => actual.quotaMinutes), 90),
-    filesChangedP50: estimateLearningPercentile(completed.map((actual) => actual.filesChanged), 50),
-    filesChangedP90: estimateLearningPercentile(completed.map((actual) => actual.filesChanged), 90),
-    creditsP50,
-    creditsP90,
-    creditsVariance,
-    confidenceScore: estimateProfileConfidenceScore({
-      sampleCount: completed.length,
-      creditsVariance,
-      creditsP50,
-      lastSampleAt: lastCreatedAt.at(-1) ?? null,
-      now: input.now
-    }),
-    outlierCount: outlierLimit === null ? 0 : credits.filter((value) => value > outlierLimit).length,
-    partialCredits,
-    firstSampleAt: lastCreatedAt[0] ?? null,
-    lastSampleAt: lastCreatedAt.at(-1) ?? null,
-    updatedAt
-  };
-}
-const DEFAULT_EXECUTION_PROFILES = {
-  "local-runner": {
-    id: "local-runner",
-    modelClass: "local",
-    qualityWeight: 1,
-    costMultiplier: 1,
-    latencyClass: "low",
-    concurrencyClass: "read_only",
-    quotaBehavior: "compute_bound"
-  },
-  "local-fast-model": {
-    id: "local-fast-model",
-    modelClass: "local",
-    qualityWeight: 0.65,
-    costMultiplier: 0.35,
-    latencyClass: "low",
-    concurrencyClass: "read_only",
-    quotaBehavior: "compute_bound"
-  },
-  "small-code-model": {
-    id: "small-code-model",
-    modelClass: "coding",
-    qualityWeight: 0.75,
-    costMultiplier: 0.5,
-    latencyClass: "low",
-    concurrencyClass: "repository_claim",
-    quotaBehavior: "api_metered"
-  },
-  "standard-code-model": {
-    id: "standard-code-model",
-    modelClass: "coding",
-    qualityWeight: 1,
-    costMultiplier: 1,
-    latencyClass: "medium",
-    concurrencyClass: "repository_claim",
-    quotaBehavior: "api_metered"
-  },
-  "large-reasoning-model": {
-    id: "large-reasoning-model",
-    modelClass: "reasoning",
-    qualityWeight: 1.5,
-    costMultiplier: 3,
-    latencyClass: "high",
-    concurrencyClass: "exclusive_project",
-    quotaBehavior: "api_metered"
-  },
-  "long-context-architect": {
-    id: "long-context-architect",
-    modelClass: "reasoning",
-    contextWindowTokens: 2e5,
-    qualityWeight: 1.75,
-    costMultiplier: 4,
-    latencyClass: "high",
-    concurrencyClass: "exclusive_project",
-    quotaBehavior: "api_metered"
-  },
-  "cheap-review-model": {
-    id: "cheap-review-model",
-    modelClass: "review",
-    qualityWeight: 0.8,
-    costMultiplier: 0.6,
-    latencyClass: "low",
-    concurrencyClass: "read_only",
-    quotaBehavior: "api_metered"
-  },
-  "human-review": {
-    id: "human-review",
-    modelClass: "human",
-    qualityWeight: 2,
-    costMultiplier: 10,
-    latencyClass: "high",
-    concurrencyClass: "human_attention",
-    quotaBehavior: "attention_bound"
-  }
-};
-const DEFAULT_TASK_ADMISSION_POLICY = {
-  planningThresholdCredits: 20,
-  approvalThresholdCredits: 50,
-  reserveBufferPercent: 15,
-  recoveryBudgetCredits: 0,
-  maxDownstreamTasks: 4,
-  maxPlanningDepth: 2,
-  maxAdmittedPlanTasksPerCycle: 4,
-  planningTaskSignature: "planner.dag_proposal",
-  allowBackfill: true,
-  maxAttentionLoad: null,
-  reserveAttentionPercent: 0,
-  maxContextTokens: null,
-  maxContextSaturationPercent: 100,
-  coordinationOverheadFactor: 1,
-  predictiveReservePolicy: null,
-  utilityPolicy: null
-};
-function normalizeExecutionProfile(input) {
-  if (!input) return DEFAULT_EXECUTION_PROFILES["standard-code-model"];
-  if (typeof input === "string") {
-    return DEFAULT_EXECUTION_PROFILES[input] ?? {
-      id: input,
-      qualityWeight: 1,
-      costMultiplier: 1,
-      latencyClass: "medium",
-      metadata: { source: "ad_hoc" }
-    };
-  }
-  return {
-    ...input,
-    qualityWeight: positiveNumber(input.qualityWeight, 1),
-    costMultiplier: positiveNumber(input.costMultiplier, 1),
-    latencyClass: input.latencyClass || "medium"
-  };
-}
-function normalizeTaskAdmissionPolicy(input = {}) {
-  const reserveBufferPercent = nonNegativeNumber(input?.reserveBufferPercent, DEFAULT_TASK_ADMISSION_POLICY.reserveBufferPercent);
-  return {
-    ...DEFAULT_TASK_ADMISSION_POLICY,
-    ...input ?? {},
-    planningThresholdCredits: positiveNumber(input?.planningThresholdCredits, DEFAULT_TASK_ADMISSION_POLICY.planningThresholdCredits),
-    approvalThresholdCredits: positiveNumber(input?.approvalThresholdCredits, DEFAULT_TASK_ADMISSION_POLICY.approvalThresholdCredits),
-    reserveBufferPercent: Math.min(100, reserveBufferPercent),
-    recoveryBudgetCredits: nonNegativeNumber(input?.recoveryBudgetCredits, DEFAULT_TASK_ADMISSION_POLICY.recoveryBudgetCredits),
-    maxDownstreamTasks: Math.max(0, Math.floor(nonNegativeNumber(input?.maxDownstreamTasks, DEFAULT_TASK_ADMISSION_POLICY.maxDownstreamTasks))),
-    maxPlanningDepth: Math.max(0, Math.floor(nonNegativeNumber(input?.maxPlanningDepth, DEFAULT_TASK_ADMISSION_POLICY.maxPlanningDepth))),
-    maxAdmittedPlanTasksPerCycle: Math.max(1, Math.floor(nonNegativeNumber(input?.maxAdmittedPlanTasksPerCycle, DEFAULT_TASK_ADMISSION_POLICY.maxAdmittedPlanTasksPerCycle))),
-    planningTaskSignature: typeof input?.planningTaskSignature === "string" && input.planningTaskSignature.trim() ? input.planningTaskSignature.trim() : DEFAULT_TASK_ADMISSION_POLICY.planningTaskSignature,
-    allowBackfill: input?.allowBackfill ?? DEFAULT_TASK_ADMISSION_POLICY.allowBackfill,
-    maxAttentionLoad: finiteOrParsedNumber(input?.maxAttentionLoad) ?? DEFAULT_TASK_ADMISSION_POLICY.maxAttentionLoad,
-    reserveAttentionPercent: Math.min(100, nonNegativeNumber(input?.reserveAttentionPercent, DEFAULT_TASK_ADMISSION_POLICY.reserveAttentionPercent ?? 0)),
-    maxContextTokens: finiteOrParsedNumber(input?.maxContextTokens) ?? DEFAULT_TASK_ADMISSION_POLICY.maxContextTokens,
-    maxContextSaturationPercent: Math.min(100, positiveNumber(input?.maxContextSaturationPercent, DEFAULT_TASK_ADMISSION_POLICY.maxContextSaturationPercent ?? 100)),
-    coordinationOverheadFactor: nonNegativeNumber(input?.coordinationOverheadFactor, DEFAULT_TASK_ADMISSION_POLICY.coordinationOverheadFactor ?? 1)
-  };
-}
-function normalizeAttentionPolicy(input = {}) {
-  return {
-    maxAttentionLoad: finiteOrParsedNumber(input?.maxAttentionLoad) ?? null,
-    reserveAttentionPercent: Math.min(100, nonNegativeNumber(input?.reserveAttentionPercent, 0)),
-    maxContextTokens: finiteOrParsedNumber(input?.maxContextTokens) ?? null,
-    maxContextSaturationPercent: Math.min(100, positiveNumber(input?.maxContextSaturationPercent, 100)),
-    coordinationOverheadFactor: nonNegativeNumber(input?.coordinationOverheadFactor, 1)
-  };
-}
-function normalizeUtilityPolicy(input = {}) {
-  return {
-    minimumUtilityScore: finiteOrParsedNumber(input?.minimumUtilityScore) ?? null,
-    minimumUtilityPerCredit: finiteOrParsedNumber(input?.minimumUtilityPerCredit) ?? null,
-    riskPenaltyFactor: nonNegativeNumber(input?.riskPenaltyFactor, 1),
-    deadlineWindowHours: positiveNumber(input?.deadlineWindowHours, 72),
-    maintenanceWeight: nonNegativeNumber(input?.maintenanceWeight, 1),
-    priorityWeight: nonNegativeNumber(input?.priorityWeight, 1)
-  };
-}
-function normalizePredictiveReservePolicy(input = {}) {
-  const raw = readRecord(input);
-  return {
-    enabled: raw.enabled === true || raw.enabled === "true",
-    baseReservePercent: Math.min(100, nonNegativeNumber(input?.baseReservePercent, 0)),
-    maxReservePercent: Math.min(100, positiveNumber(input?.maxReservePercent, 50)),
-    incidentReservePercent: Math.min(100, nonNegativeNumber(input?.incidentReservePercent, 15)),
-    triggerBurstReservePercent: Math.min(100, nonNegativeNumber(input?.triggerBurstReservePercent, 10)),
-    deploymentWindowReservePercent: Math.min(100, nonNegativeNumber(input?.deploymentWindowReservePercent, 10)),
-    providerDegradationReservePercent: Math.min(100, nonNegativeNumber(input?.providerDegradationReservePercent, 10)),
-    quotaPressureReservePercent: Math.min(100, nonNegativeNumber(input?.quotaPressureReservePercent, 10))
-  };
-}
-function isoHoursUntil(value, now) {
-  if (typeof value !== "string" || !value.trim()) return null;
-  const target = new Date(value);
-  if (!Number.isFinite(target.valueOf())) return null;
-  return (target.valueOf() - now.valueOf()) / 36e5;
-}
-function riskPenalty(classification, policy) {
-  if (classification?.risk === "high") return 20 * policy.riskPenaltyFactor;
-  if (classification?.risk === "medium") return 8 * policy.riskPenaltyFactor;
-  return 0;
-}
-function qualityScoreFromProfile(profile, confidence) {
-  const confidenceWeight = confidence === "high" ? 1.1 : confidence === "low" ? 0.75 : 1;
-  return Math.max(0, profile.qualityWeight * confidenceWeight);
-}
-function estimateUtilityForTask(input) {
-  const policy = normalizeUtilityPolicy(input.utilityPolicy);
-  const profile = normalizeExecutionProfile(input.executionProfile);
-  const metadata = readRecord(input.metadata);
-  const priority = Math.max(0, finiteOrParsedNumber(input.priority) ?? finiteOrParsedNumber(metadata.priority) ?? 0);
-  const explicitUtility = finiteOrParsedNumber(input.utilityValue) ?? finiteOrParsedNumber(metadata.utilityValue);
-  const maintenanceValue = Math.max(0, finiteOrParsedNumber(input.maintenanceValue) ?? finiteOrParsedNumber(metadata.maintenanceValue) ?? 0);
-  const now = input.now instanceof Date ? input.now : new Date(input.now ?? Date.now());
-  const hoursUntilDeadline = isoHoursUntil(input.deadlineAt ?? metadata.deadlineAt, now);
-  const deadlinePressure = hoursUntilDeadline === null ? 0 : Math.max(0, Math.min(30, (policy.deadlineWindowHours - hoursUntilDeadline) / Math.max(1, policy.deadlineWindowHours) * 30));
-  const successProbability = Math.max(0, Math.min(1, finiteOrParsedNumber(input.successProbability) ?? finiteOrParsedNumber(metadata.successProbability) ?? 1));
-  const qualityScore = qualityScoreFromProfile(profile, input.classification?.confidence);
-  const baseUtility = explicitUtility ?? priority * policy.priorityWeight + maintenanceValue * policy.maintenanceWeight;
-  const risk = riskPenalty(input.classification, policy);
-  const utilityScore = Math.max(0, (baseUtility + deadlinePressure) * successProbability * Math.max(0.1, qualityScore) - risk);
-  const reservedCredits = Math.max(1, finiteOrParsedNumber(input.estimate?.reservedCredits) ?? 1);
-  return {
-    utilityValue: Math.max(0, baseUtility),
-    maintenanceValue,
-    deadlinePressure,
-    successProbability,
-    qualityScore,
-    riskPenalty: risk,
-    utilityScore,
-    utilityPerCredit: utilityScore / reservedCredits,
-    source: input.source ?? "capacity_utility_estimator",
-    metadata
-  };
-}
-function reserveSignalFlag(metadata, ...keys) {
-  return keys.some((key) => metadata[key] === true || metadata[key] === "true");
-}
-function predictReserveForCapacityPlan(input) {
-  const policy = normalizePredictiveReservePolicy(input.policy);
-  const metadata = readRecord(input.metadata);
-  const reasons = [];
-  const signals = {};
-  let reservePercent = policy.enabled ? policy.baseReservePercent : 0;
-  const providerDegraded = input.plan?.providers.some((provider) => provider.status === "degraded" || metadataStatus(provider.metadata) === "degraded") ?? false;
-  const quotaPressure = input.plan?.providers.some((provider) => {
-    const pressure = readRecord(provider.metadata?.pressure);
-    const quota = finiteOrParsedNumber(pressure.quotaRemainingPercent) ?? finiteOrParsedNumber(provider.metadata?.quotaRemainingPercent);
-    return quota !== null && quota < 20;
-  }) ?? false;
-  if (policy.enabled && reserveSignalFlag(metadata, "incidentLikely", "likelyIncident")) {
-    reservePercent += policy.incidentReservePercent;
-    reasons.push("incident_reserve");
-    signals.incidentLikely = true;
-  }
-  if (policy.enabled && reserveSignalFlag(metadata, "triggerBurstLikely", "expectedTriggerBurst")) {
-    reservePercent += policy.triggerBurstReservePercent;
-    reasons.push("trigger_burst_reserve");
-    signals.triggerBurstLikely = true;
-  }
-  if (policy.enabled && reserveSignalFlag(metadata, "deploymentWindow", "deploymentWindowActive")) {
-    reservePercent += policy.deploymentWindowReservePercent;
-    reasons.push("deployment_window_reserve");
-    signals.deploymentWindow = true;
-  }
-  if (policy.enabled && providerDegraded) {
-    reservePercent += policy.providerDegradationReservePercent;
-    reasons.push("provider_degradation_reserve");
-    signals.providerDegraded = true;
-  }
-  if (policy.enabled && quotaPressure) {
-    reservePercent += policy.quotaPressureReservePercent;
-    reasons.push("quota_pressure_reserve");
-    signals.quotaPressure = true;
-  }
-  const boundedPercent = Math.min(policy.maxReservePercent, Math.max(0, reservePercent));
-  const budget = Math.max(0, finiteOrParsedNumber(input.dailyCreditBudget) ?? finiteOrParsedNumber(input.remainingCredits) ?? input.plan?.remaining.dailyCredits ?? 0);
-  const reserveCredits = Math.ceil(budget * boundedPercent / 100);
-  const remaining = Math.max(0, finiteOrParsedNumber(input.remainingCredits) ?? input.plan?.remaining.dailyCredits ?? budget);
-  return {
-    reservePercent: boundedPercent,
-    reserveCredits,
-    activelyAllocatableCredits: Math.max(0, remaining - reserveCredits),
-    reasons,
-    signals
-  };
-}
-function normalizeHybridExecutionPlan(input) {
-  const record = readRecord(input);
-  const rawPhases = Array.isArray(record.phases) ? record.phases : [];
-  const phases = rawPhases.map((phase, index) => {
-    const entry = readRecord(phase);
-    const kind = typeof entry.kind === "string" && entry.kind.trim() ? entry.kind.trim() : `phase_${index + 1}`;
-    const executionProfileId = typeof entry.executionProfileId === "string" && entry.executionProfileId.trim() ? entry.executionProfileId.trim() : typeof entry.executionProfile === "string" && entry.executionProfile.trim() ? entry.executionProfile.trim() : DEFAULT_EXECUTION_PROFILE_ID;
-    const mutationAllowed = entry.mutationAllowed === true || kind === "implementation" && entry.mutationAllowed !== false;
-    return {
-      id: typeof entry.id === "string" && entry.id.trim() ? entry.id.trim() : kind,
-      kind,
-      executionProfileId,
-      taskSignature: typeof entry.taskSignature === "string" && entry.taskSignature.trim() ? entry.taskSignature.trim() : null,
-      required: entry.required !== false,
-      admissionRequired: entry.admissionRequired !== false,
-      mutationAllowed,
-      metadata: readRecord(entry.metadata)
-    };
-  });
-  if (phases.length === 0) return null;
-  return {
-    schemaVersion: 1,
-    planId: typeof record.planId === "string" && record.planId.trim() ? record.planId.trim() : "hybrid-execution-plan",
-    phases,
-    escalationPolicy: readRecord(record.escalationPolicy),
-    metadata: readRecord(record.metadata)
-  };
-}
-function normalizePlanningPolicy(input = {}) {
-  const admissionPolicy = normalizeTaskAdmissionPolicy(input);
-  return {
-    maxDownstreamTasks: admissionPolicy.maxDownstreamTasks,
-    maxPlanningDepth: admissionPolicy.maxPlanningDepth,
-    maxAdmittedPlanTasksPerCycle: admissionPolicy.maxAdmittedPlanTasksPerCycle,
-    planningTaskSignature: admissionPolicy.planningTaskSignature
-  };
-}
-function stablePlanId(input) {
-  const source = typeof input.sourceTaskId === "string" && input.sourceTaskId.trim() ? input.sourceTaskId.trim() : typeof input.parentTaskId === "string" && input.parentTaskId.trim() ? input.parentTaskId.trim() : "plan";
-  return `${source}:proposal`;
-}
-function readRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function readPlanString(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : "";
-}
-function normalizePlannedTaskNode(value, index) {
-  const input = readRecord(value);
-  const payload = readRecord(input.payload);
-  const type = readPlanString(input.type) || readPlanString(payload.type);
-  if (!type) return null;
-  const id = readPlanString(input.id) || `node-${index + 1}`;
-  const p50 = finiteNumber(input.estimatedCreditsP50) ?? finiteNumber(payload.estimatedCreditsP50) ?? finiteNumber(input.estimatedCredits) ?? finiteNumber(payload.estimatedCredits) ?? null;
-  const p90 = finiteNumber(input.estimatedCreditsP90) ?? finiteNumber(payload.estimatedCreditsP90) ?? p50;
-  return {
-    id,
-    type,
-    agentId: readPlanString(input.agentId) || readPlanString(payload.agentId) || null,
-    title: readPlanString(input.title) || null,
-    priority: finiteNumber(input.priority) ?? finiteNumber(payload.priority),
-    taskSignature: readPlanString(input.taskSignature) || readPlanString(payload.taskSignature) || null,
-    payload,
-    estimatedCreditsP50: p50,
-    estimatedCreditsP90: p90,
-    risk: input.risk === "low" || input.risk === "medium" || input.risk === "high" ? input.risk : null,
-    mutationScope: input.mutationScope === "none" || input.mutationScope === "repository_read" || input.mutationScope === "repository_write" || input.mutationScope === "production" ? input.mutationScope : null,
-    confidence: input.confidence === "low" || input.confidence === "medium" || input.confidence === "high" ? input.confidence : null,
-    expectedFanout: finiteNumber(input.expectedFanout) ?? finiteNumber(payload.expectedFanout),
-    requiresApproval: typeof input.requiresApproval === "boolean" ? input.requiresApproval : null,
-    requiresPlanning: typeof input.requiresPlanning === "boolean" ? input.requiresPlanning : null,
-    dependsOn: Array.isArray(input.dependsOn) ? input.dependsOn.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [],
-    metadata: readRecord(input.metadata)
-  };
-}
-function synthesizePlanEstimate(tasks) {
-  const totalEstimatedCreditsP50 = tasks.reduce((total, task) => total + Math.max(0, Math.ceil(finiteNumber(task.estimatedCreditsP50) ?? finiteNumber(task.estimatedCreditsP90) ?? 1)), 0);
-  const totalEstimatedCreditsP90 = tasks.reduce((total, task) => {
-    const p50 = Math.max(1, Math.ceil(finiteNumber(task.estimatedCreditsP50) ?? 1));
-    return total + Math.max(p50, Math.ceil(finiteNumber(task.estimatedCreditsP90) ?? p50));
-  }, 0);
-  return {
-    totalEstimatedCreditsP50,
-    totalEstimatedCreditsP90
-  };
-}
-function rankPlannedTaskNodes(tasks) {
-  const boundedness = (task) => {
-    const fanout = Math.max(0, Math.floor(finiteNumber(task.expectedFanout) ?? 0));
-    const riskPenalty2 = task.risk === "high" ? 3 : task.risk === "medium" ? 1 : 0;
-    const mutationPenalty = task.mutationScope === "production" ? 4 : task.mutationScope === "repository_write" ? 2 : 0;
-    return fanout + riskPenalty2 + mutationPenalty;
-  };
-  return [...tasks].sort((left, right) => {
-    const priorityDelta = (finiteNumber(right.priority) ?? 0) - (finiteNumber(left.priority) ?? 0);
-    if (priorityDelta !== 0) return priorityDelta;
-    const boundedDelta = boundedness(left) - boundedness(right);
-    if (boundedDelta !== 0) return boundedDelta;
-    return String(left.id ?? left.type).localeCompare(String(right.id ?? right.type));
-  });
-}
-function normalizeTaskPlanProposal(input, policyInput) {
-  const policy = normalizePlanningPolicy(policyInput);
-  const record = readRecord(input);
-  const tasks = (Array.isArray(record.tasks) ? record.tasks : []).map((entry, index) => normalizePlannedTaskNode(entry, index)).filter((entry) => Boolean(entry));
-  const estimate = synthesizePlanEstimate(tasks);
-  const planningDepth = Math.max(0, Math.floor(finiteNumber(record.planningDepth) ?? 0));
-  return {
-    schemaVersion: 1,
-    planId: readPlanString(record.planId) || stablePlanId(record),
-    sourceTaskId: readPlanString(record.sourceTaskId) || null,
-    parentTaskId: readPlanString(record.parentTaskId) || null,
-    planningDepth,
-    tasks,
-    totalEstimatedCreditsP50: Math.max(0, Math.ceil(finiteNumber(record.totalEstimatedCreditsP50) ?? estimate.totalEstimatedCreditsP50)),
-    totalEstimatedCreditsP90: Math.max(0, Math.ceil(finiteNumber(record.totalEstimatedCreditsP90) ?? estimate.totalEstimatedCreditsP90)),
-    createdAt: readPlanString(record.createdAt) || null,
-    metadata: readRecord(record.metadata)
-  };
-}
-function validateTaskPlanProposal(input, policyInput) {
-  const policy = normalizePlanningPolicy(policyInput);
-  const reasons = [];
-  if (input.planningDepth > policy.maxPlanningDepth) {
-    reasons.push("planning_depth_exceeded");
-  }
-  if (input.tasks.length > policy.maxDownstreamTasks) {
-    reasons.push("fanout_limit_exceeded");
-  }
-  const rejected = input.tasks.map((node) => {
-    const nodeReasons = [];
-    if (!node.type) nodeReasons.push("missing_type");
-    if (Math.max(0, Math.floor(finiteNumber(node.expectedFanout) ?? 0)) > policy.maxDownstreamTasks) {
-      nodeReasons.push("node_fanout_limit_exceeded");
-    }
-    return nodeReasons.length > 0 ? { node, reasons: nodeReasons } : null;
-  }).filter((entry) => Boolean(entry));
-  return {
-    ok: reasons.length === 0 && rejected.length === 0,
-    reasons,
-    rejected
-  };
-}
-function progressivelyAdmitPlanProposal(input) {
-  const policy = normalizePlanningPolicy(input.policy);
-  const proposal = normalizeTaskPlanProposal(input.proposal, policy);
-  const validation = validateTaskPlanProposal(proposal, policy);
-  const reasons = [...validation.reasons];
-  const admitted = [];
-  const deferred = [];
-  const rejected = [...validation.rejected];
-  if (!validation.ok) {
-    return {
-      proposal,
-      admitted,
-      deferred: proposal.tasks.filter((node) => !rejected.some((entry) => entry.node.id === node.id)),
-      rejected,
-      totalEstimatedCreditsP50: proposal.totalEstimatedCreditsP50,
-      totalEstimatedCreditsP90: proposal.totalEstimatedCreditsP90,
-      admittedCreditsP90: 0,
-      reasons
-    };
-  }
-  let availableCredits = Math.max(0, Math.floor(nonNegativeNumber(input.availableCredits, Number.POSITIVE_INFINITY)));
-  let remainingQueuedCredits = Math.max(0, Math.floor(nonNegativeNumber(input.remainingQueuedCredits, Number.POSITIVE_INFINITY)));
-  let remainingQueuedSlots = Math.max(0, Math.floor(nonNegativeNumber(input.remainingQueuedSlots, policy.maxAdmittedPlanTasksPerCycle)));
-  let admittedCreditsP90 = 0;
-  for (const task of rankPlannedTaskNodes(proposal.tasks)) {
-    if (admitted.length >= policy.maxAdmittedPlanTasksPerCycle || remainingQueuedSlots <= 0) {
-      deferred.push(task);
-      reasons.push("plan_cycle_limit_reached");
-      continue;
-    }
-    const p50 = Math.max(1, Math.ceil(finiteNumber(task.estimatedCreditsP50) ?? 1));
-    const p90 = Math.max(p50, Math.ceil(finiteNumber(task.estimatedCreditsP90) ?? p50));
-    if (p90 > availableCredits || p90 > remainingQueuedCredits) {
-      deferred.push(task);
-      reasons.push("insufficient_plan_budget");
-      continue;
-    }
-    admitted.push(task);
-    admittedCreditsP90 += p90;
-    availableCredits -= p90;
-    remainingQueuedCredits -= p90;
-    remainingQueuedSlots -= 1;
-  }
-  return {
-    proposal,
-    admitted,
-    deferred,
-    rejected,
-    totalEstimatedCreditsP50: proposal.totalEstimatedCreditsP50,
-    totalEstimatedCreditsP90: proposal.totalEstimatedCreditsP90,
-    admittedCreditsP90,
-    reasons: [...new Set(reasons)]
-  };
-}
-function computeWorkdayBudgetEnvelope(input) {
-  const dailyCreditBudget = Math.max(0, Math.floor(nonNegativeNumber(input.dailyCreditBudget, 0)));
-  const usedCredits = Math.max(0, Math.ceil(nonNegativeNumber(input.usedCredits, 0)));
-  const queuedCredits = Math.max(0, Math.ceil(nonNegativeNumber(input.queuedCredits, 0)));
-  const reservePercent = Math.min(100, Math.max(0, nonNegativeNumber(input.reserveBufferPercent, DEFAULT_TASK_ADMISSION_POLICY.reserveBufferPercent)));
-  const reserveBufferCredits = Math.ceil(dailyCreditBudget * reservePercent / 100);
-  const recoveryBudgetCredits = Math.ceil(nonNegativeNumber(input.recoveryBudgetCredits, DEFAULT_TASK_ADMISSION_POLICY.recoveryBudgetCredits));
-  const remainingCredits = Math.max(0, dailyCreditBudget - usedCredits - queuedCredits);
-  const activelyAllocatableCredits = Math.max(0, dailyCreditBudget - usedCredits - queuedCredits - reserveBufferCredits - recoveryBudgetCredits);
-  return {
-    dailyCreditBudget,
-    usedCredits,
-    queuedCredits,
-    reserveBufferCredits,
-    recoveryBudgetCredits,
-    activelyAllocatableCredits,
-    remainingCredits
-  };
-}
-function mutationRequiresRepositoryClaim(scope) {
-  return scope === "repository_write" || scope === "production";
-}
-function reservationDebit(reservation) {
-  if (reservation.state === "released" || reservation.state === "expired" || reservation.state === "cancelled") {
-    return 0;
-  }
-  if (reservation.state === "consumed" || reservation.state === "failed") {
-    return Math.max(0, reservation.consumedCredits);
-  }
-  return Math.max(reservation.reservedCredits, reservation.consumedCredits, 0);
-}
-function activeReservationDebit(reservation) {
-  if (reservation.state === "reserved" || reservation.state === "consuming") {
-    return Math.max(reservation.reservedCredits, reservation.consumedCredits, 0);
-  }
-  if (reservation.state === "consumed" || reservation.state === "failed") {
-    return Math.max(reservation.consumedCredits, 0);
-  }
-  return 0;
-}
-function metadataNumber(metadata, ...keys) {
-  for (const key of keys) {
-    const value = finiteOrParsedNumber(metadata?.[key]);
-    if (value !== null) return value;
-  }
-  return null;
-}
-function metadataBoolean(metadata, ...keys) {
-  for (const key of keys) {
-    const value = metadata?.[key];
-    if (value === true || value === "true" || value === 1 || value === "1") return true;
-    if (value === false || value === "false" || value === 0 || value === "0") return false;
-  }
-  return false;
-}
-function grantMatchesReservation(grant, reservation) {
-  if (grant.teamId !== reservation.teamId) return false;
-  if (grant.capacityProviderId !== reservation.capacityProviderId) return false;
-  if (grant.laneId && grant.laneId !== reservation.laneId) return false;
-  if (grant.projectId && grant.projectId !== reservation.projectId) return false;
-  return true;
-}
-function grantPortfolioAllocationPercent(grant) {
-  const metadata = readRecord(grant.metadata);
-  const value = finiteOrParsedNumber(grant.portfolioAllocationPercent) ?? metadataNumber(metadata, "portfolioAllocationPercent", "allocationPercent", "derivedAllocationPercent", "percentOfDerivedCapacity");
-  if (value === null) return null;
-  return Math.max(0, Math.min(100, value));
-}
-function grantReservePoolPercent(grant) {
-  const metadata = readRecord(grant.metadata);
-  const value = finiteOrParsedNumber(grant.reservePoolPercent) ?? metadataNumber(metadata, "reservePoolPercent", "minimumReservePercent", "reservePercent");
-  if (value === null) return 0;
-  return Math.max(0, Math.min(100, value));
-}
-function grantMaxDailyProjectCredits(grant) {
-  const metadata = readRecord(grant.metadata);
-  const value = finiteOrParsedNumber(grant.maxDailyProjectCredits) ?? metadataNumber(metadata, "maxDailyProjectCredits", "dailyProjectCreditCap");
-  if (value === null) return null;
-  return Math.max(0, value);
-}
-function grantEmergencyOverrideEnabled(grant) {
-  return grant.emergencyOverride === true || metadataBoolean(readRecord(grant.metadata), "emergencyOverride", "emergencyOverrideEnabled");
-}
-function routeEmergencyOverrideRequested(input) {
-  return metadataBoolean(readRecord(input.metadata), "emergencyOverride", "emergencyOverrideRequested");
-}
-function grantPortfolioCreditLimit(grant, derivedCapacity) {
-  const percent = grantPortfolioAllocationPercent(grant);
-  if (percent === null || !derivedCapacity || derivedCapacity.derivedAvailableCredits === null) return null;
-  return Math.max(0, derivedCapacity.derivedAvailableCredits * percent / 100);
-}
-function grantRemainingCredits(plan, grant, derivedCapacity, input) {
-  const staticLimit = grant.dailyCreditLimit ?? grant.monthlyCreditLimit;
-  const portfolioLimit = grantPortfolioCreditLimit(grant, derivedCapacity);
-  const maxDailyProjectCredits = grantMaxDailyProjectCredits(grant);
-  const limits = [staticLimit, portfolioLimit, maxDailyProjectCredits].filter((value) => value !== null && value !== void 0);
-  const limit = limits.length > 0 ? Math.min(...limits.map((value) => Number(value))) : null;
-  if (limit === null || limit === void 0) return null;
-  const reservePoolPercent = portfolioLimit !== null ? grantReservePoolPercent(grant) : 0;
-  const emergencyOverride = input ? routeEmergencyOverrideRequested(input) && grantEmergencyOverrideEnabled(grant) : false;
-  const reservePoolCredits = emergencyOverride ? 0 : limit * reservePoolPercent / 100;
-  const debits = plan.activeReservations.filter((reservation) => grantMatchesReservation(grant, reservation)).reduce((total, reservation) => total + reservationDebit(reservation), 0);
-  return Math.max(0, Number(limit) - reservePoolCredits - debits);
-}
-function providerIsEligible(provider, input) {
-  if (provider.status === "active") return true;
-  if (provider.status === "degraded" && input.allowDegradedProviders) return true;
-  return false;
-}
-function grantIsEligible(grant, input) {
-  if (grant.state !== "active") return false;
-  if (grant.teamId !== input.plan.teamId) return false;
-  if (grant.environment && grant.environment !== input.plan.environment) return false;
-  if (grant.projectId && grant.projectId !== input.plan.projectId) return false;
-  return true;
-}
-function lanePolicyReasons(lane, input) {
-  const reasons = [];
-  const laneStatus = metadataStatus(lane.metadata);
-  if (laneStatus && laneStatus !== "active") reasons.push(`lane_status:${laneStatus}`);
-  const policy = lane.routingPolicy ?? {};
-  const taskKinds = stringArray(policy.taskKinds);
-  const taskKind = input.taskKind ?? input.estimate.taskSignature;
-  if (taskKinds.length > 0 && !taskKinds.includes(taskKind)) reasons.push("task_kind_mismatch");
-  const requiredCapabilities = stringArray(policy.requiredCapabilities);
-  const missingCapabilities = (input.requiredCapabilities ?? []).filter((capability) => !requiredCapabilities.includes(capability));
-  if (requiredCapabilities.length > 0 && missingCapabilities.length > 0) {
-    reasons.push("capability_mismatch");
-  }
-  const allowedEnvironments = stringArray(policy.allowedEnvironments);
-  if (allowedEnvironments.length > 0 && !allowedEnvironments.includes(input.plan.environment)) {
-    reasons.push("environment_mismatch");
-  }
-  const maxCreditsPerTask = numberValue(policy.maxCreditsPerTask);
-  if (maxCreditsPerTask !== null && input.estimate.reservedCredits > maxCreditsPerTask) {
-    reasons.push("task_credit_limit_exceeded");
-  }
-  const approvalThreshold = numberValue(policy.requiresApprovalAboveCredits);
-  if (approvalThreshold !== null && input.estimate.reservedCredits > approvalThreshold) {
-    reasons.push("approval_required");
-  }
-  const repositoryMutationAllowed = booleanValue(policy.repositoryMutationAllowed);
-  if (input.repositoryMutation && repositoryMutationAllowed === false) {
-    reasons.push("repository_mutation_not_allowed");
-  }
-  const productionAllowed = booleanValue(policy.productionAllowed);
-  if (input.production && productionAllowed === false) {
-    reasons.push("production_not_allowed");
-  }
-  return reasons;
-}
-function reserveCreditsForEstimate(input) {
-  const executionProfile = input.executionProfile ? normalizeExecutionProfile(input.executionProfile) : input.executionProfileId ? normalizeExecutionProfile(input.executionProfileId) : null;
-  const selectedProfile = input.profile ?? selectTaskEstimateProfile({
-    profiles: input.profiles,
-    taskSignature: input.taskSignature ?? input.taskKind,
-    executionProfile,
-    executionProfileId: input.executionProfileId
-  });
-  const profileP50 = finiteNumber(selectedProfile?.creditsP50);
-  const profileP90 = finiteNumber(selectedProfile?.creditsP90);
-  const costMultiplier = positiveNumber(input.costMultiplier ?? executionProfile?.costMultiplier ?? 1, 1);
-  const p50 = Math.max(1, Math.ceil(
-    finiteNumber(input.estimatedCreditsP50) ?? profileP50 ?? finiteNumber(input.defaultCredits) ?? 1
-  ));
-  const p90 = Math.max(p50, Math.ceil(
-    finiteNumber(input.estimatedCreditsP90) ?? profileP90 ?? p50 * 2
-  ));
-  const profileConfidence = selectedProfile ? estimateConfidenceFromProfile(selectedProfile) : null;
-  const confidence = input.confidence ?? profileConfidence ?? "medium";
-  const baseReserved = confidence === "high" ? Math.max(p50, Math.ceil((p50 + p90) * 0.75)) : p90;
-  const reserved = Math.max(1, Math.ceil(baseReserved * costMultiplier));
-  return {
-    taskSignature: input.taskSignature ?? input.taskKind ?? "unknown",
-    confidence,
-    estimatedCreditsP50: p50,
-    estimatedCreditsP90: p90,
-    reservedCredits: reserved,
-    baseReservedCredits: baseReserved,
-    executionProfileId: executionProfile?.id ?? input.executionProfileId ?? selectedProfile?.executionProfileId ?? null,
-    costMultiplier
-  };
-}
-function estimateForClassification(input) {
-  const classification = input.classification ?? null;
-  return reserveCreditsForEstimate({
-    ...input,
-    taskSignature: input.taskSignature ?? classification?.taskSignature,
-    confidence: input.confidence ?? classification?.confidence
-  });
-}
-function decideTaskAdmission(input) {
-  const policy = normalizeTaskAdmissionPolicy(input.policy);
-  const budget = computeWorkdayBudgetEnvelope({
-    ...input.budget,
-    reserveBufferPercent: policy.reserveBufferPercent,
-    recoveryBudgetCredits: policy.recoveryBudgetCredits
-  });
-  const reasons = [];
-  const reservedCredits = Math.max(1, Math.ceil(input.estimate.reservedCredits));
-  const fanout = Math.max(0, Math.floor(input.classification.expectedFanout ?? 0));
-  const highRisk = input.classification.risk === "high" || input.classification.mutationScope === "production";
-  const requiresPlanning = input.classification.requiresPlanning || fanout > policy.maxDownstreamTasks || reservedCredits >= policy.planningThresholdCredits && (input.classification.confidence === "low" || fanout > 1 || highRisk);
-  const requiresApproval = input.classification.requiresApproval || highRisk || reservedCredits >= policy.approvalThresholdCredits;
-  let outcome = "admitted";
-  if (!input.classification.taskSignature || input.classification.taskSignature === "unknown") {
-    outcome = "rejected";
-    reasons.push("unknown_task_signature");
-  }
-  if (fanout > policy.maxDownstreamTasks) {
-    reasons.push("fanout_limit_exceeded");
-  }
-  if (requiresPlanning) {
-    outcome = "planning_required";
-    reasons.push("planning_required");
-  }
-  if (requiresApproval) {
-    outcome = "approval_required";
-    reasons.push("approval_required");
-  }
-  if (outcome === "admitted" && reservedCredits > budget.activelyAllocatableCredits) {
-    outcome = "budget_blocked";
-    reasons.push("insufficient_allocatable_budget");
-  }
-  return {
-    outcome,
-    taskSignature: input.classification.taskSignature,
-    estimatedCreditsP50: input.estimate.estimatedCreditsP50,
-    estimatedCreditsP90: input.estimate.estimatedCreditsP90,
-    reservedCredits,
-    baseReservedCredits: input.estimate.baseReservedCredits,
-    executionProfileId: input.estimate.executionProfileId ?? null,
-    costMultiplier: input.estimate.costMultiplier ?? null,
-    reasons: [...new Set(reasons)],
-    requiresApproval,
-    requiresPlanning,
-    budget,
-    policySnapshot: policy,
-    metadata: {
-      ...input.metadata ?? {},
-      source: input.source ?? null,
-      classification: input.classification
-    }
-  };
-}
-function shouldInterruptForCapacity(input) {
-  const reservedCredits = nonNegativeNumber(input.reservedCredits, 0);
-  const consumedCredits = nonNegativeNumber(input.consumedCredits, 0);
-  const threshold = Math.min(100, Math.max(1, nonNegativeNumber(input.reservationUsedPercentThreshold, 80)));
-  const usedPercent = reservedCredits > 0 ? consumedCredits / reservedCredits * 100 : 0;
-  const estimatedRemainingP50 = nonNegativeNumber(input.estimatedRemainingCreditsP50, 0);
-  const estimatedRemainingP90 = nonNegativeNumber(input.estimatedRemainingCreditsP90, estimatedRemainingP50);
-  const recoveryBudgetRemaining = input.recoveryBudgetRemainingCredits === void 0 || input.recoveryBudgetRemainingCredits === null ? null : nonNegativeNumber(input.recoveryBudgetRemainingCredits, 0);
-  const recoveryMinimum = nonNegativeNumber(input.recoveryBudgetMinimumCredits, 3);
-  const reasons = [];
-  if (input.providerAvailable === false) {
-    reasons.push("provider_unavailable");
-  }
-  if (reservedCredits > 0 && usedPercent >= threshold && estimatedRemainingP50 > Math.max(0, reservedCredits - consumedCredits)) {
-    reasons.push("reservation_exhaustion_risk");
-  }
-  if (recoveryBudgetRemaining !== null && recoveryBudgetRemaining < recoveryMinimum) {
-    reasons.push("recovery_budget_low");
-  }
-  return {
-    interrupt: reasons.length > 0,
-    reasons,
-    usedPercent,
-    estimatedRemainingP50,
-    estimatedRemainingP90,
-    remainingReservationCredits: Math.max(0, reservedCredits - consumedCredits)
-  };
-}
-function summarizeCapacityPlan(plan) {
-  const reservedCredits = plan.activeReservations.filter((reservation) => reservation.state === "reserved" || reservation.state === "consuming").reduce((total, reservation) => total + reservation.reservedCredits, 0);
-  const consumedCredits = plan.activeReservations.reduce((total, reservation) => total + reservation.consumedCredits, 0);
-  const grantedDailyCredits = plan.grants.filter((grant) => grant.state === "active").reduce((total, grant) => total + (grant.dailyCreditLimit ?? 0), 0);
-  return {
-    grantedDailyCredits,
-    reservedCredits,
-    consumedCredits,
-    remainingDailyCredits: grantedDailyCredits > 0 ? Math.max(0, grantedDailyCredits - reservedCredits - consumedCredits) : null,
-    providerCount: plan.providers.length,
-    laneCount: plan.lanes.length,
-    grantCount: plan.grants.length
-  };
-}
-function summarizeTeamCapacityPlan(plan) {
-  const dailyCredits = plan.grants.filter((grant) => grant.state === "active").reduce((total, grant) => total + (grant.dailyCreditLimit ?? 0), 0);
-  const monthlyCredits = plan.grants.filter((grant) => grant.state === "active").reduce((total, grant) => total + (grant.monthlyCreditLimit ?? 0), 0);
-  const dailyReservedCredits = plan.activeReservations.reduce((total, reservation) => total + activeReservationDebit(reservation), 0);
-  const dailyUsedCredits = plan.activeReservations.reduce((total, reservation) => total + Math.max(0, reservation.consumedCredits), 0);
-  return {
-    teamId: plan.teamId,
-    monthlyCredits: monthlyCredits > 0 ? monthlyCredits : null,
-    monthlyUsedCredits: dailyUsedCredits,
-    monthlyRemainingCredits: monthlyCredits > 0 ? Math.max(0, monthlyCredits - dailyUsedCredits) : null,
-    dailyCredits: dailyCredits > 0 ? dailyCredits : null,
-    dailyUsedCredits,
-    dailyReservedCredits,
-    dailyRemainingCredits: dailyCredits > 0 ? Math.max(0, dailyCredits - dailyReservedCredits - dailyUsedCredits) : null,
-    providerCount: plan.providers.length,
-    activeProviderCount: plan.providers.filter((provider) => provider.status === "active").length,
-    degradedProviderCount: plan.providers.filter((provider) => provider.status === "degraded").length,
-    grantCount: plan.grants.length,
-    blockedTaskCount: 0,
-    approvalRequiredCount: 0
-  };
-}
-function summarizeProjectCapacityPlan(plan, options = {}) {
-  const summary = summarizeTeamCapacityPlan(plan);
-  const reasons = [];
-  let readiness = "ready";
-  if (options.workPolicyEnabled === false) {
-    readiness = "paused_by_policy";
-    reasons.push("work_policy_disabled");
-  } else if (summary.activeProviderCount <= 0) {
-    readiness = "waiting_for_provider";
-    reasons.push("no_active_provider");
-  } else if (summary.dailyRemainingCredits !== null && summary.dailyRemainingCredits <= 0) {
-    readiness = "waiting_for_budget";
-    reasons.push("daily_budget_exhausted");
-  } else if ((options.approvalRequiredCount ?? 0) > 0) {
-    readiness = "needs_approval";
-    reasons.push("approval_required");
-  }
-  return {
-    ...summary,
-    projectId: plan.projectId,
-    environment: plan.environment,
-    readiness,
-    reasons,
-    blockedTaskCount: options.blockedTaskCount ?? summary.blockedTaskCount,
-    approvalRequiredCount: options.approvalRequiredCount ?? summary.approvalRequiredCount
-  };
-}
-function scoreCapacityLane(input) {
-  const reasons = [];
-  let agentFit = 0;
-  const profile = input.agentProfile;
-  if (profile) {
-    const preferred = profile.preferredLanes.find(
-      (preference) => preference.laneId === input.lane.id || preference.providerId === input.lane.capacityProviderId || preference.modelClass && preference.modelClass === input.lane.modelClass || preference.provider && preference.provider === input.lane.capacityProviderId
-    );
-    if (preferred) {
-      agentFit += Math.max(0, preferred.weight);
-      reasons.push("agent_preference");
-    }
-    if (profile.disallowedProviders?.includes(input.lane.capacityProviderId)) {
-      agentFit -= 1e3;
-      reasons.push("agent_disallowed_provider");
-    }
-    if (input.region && profile.disallowedRegions?.includes(input.region)) {
-      agentFit -= 1e3;
-      reasons.push("agent_disallowed_region");
-    }
-  }
-  if (input.modelClass && input.lane.modelClass === input.modelClass) {
-    agentFit += 20;
-    reasons.push("model_class_match");
-  }
-  const fairnessScore = Math.max(0, (input.grant?.priorityWeight ?? 1) * 10);
-  const scarcity = scarcityPenalty(input.lane.scarcityLevel);
-  const remaining = input.remainingCredits;
-  const costPenalty = remaining !== null && remaining !== void 0 && remaining <= 0 ? 500 : 0;
-  if (scarcity > 0) reasons.push(`scarcity:${input.lane.scarcityLevel}`);
-  if (costPenalty > 0) reasons.push("capacity_exhausted");
-  return {
-    laneId: input.lane.id,
-    capacityProviderId: input.lane.capacityProviderId,
-    score: agentFit + fairnessScore - scarcity - costPenalty,
-    agentFit,
-    scarcityPenalty: scarcity,
-    fairnessScore,
-    costPenalty,
-    reasons
-  };
-}
-function selectBestCapacityLane(candidates) {
-  const scored = candidates.map(scoreCapacityLane).sort((left, right) => right.score - left.score || left.laneId.localeCompare(right.laneId));
-  return {
-    selected: scored[0] ?? null,
-    scores: scored
-  };
-}
-function reservationHasCapacity(reservation) {
-  return reservation.state === "reserved" && reservation.reservedCredits > reservation.consumedCredits;
-}
-function createReservationReleaseEntry(input) {
-  const credits = Math.max(0, Number(input.credits ?? input.reservation.reservedCredits - input.reservation.consumedCredits));
-  return {
-    capacityProviderId: input.reservation.capacityProviderId,
-    laneId: input.reservation.laneId,
-    reservationId: input.reservation.id,
-    teamId: input.reservation.teamId,
-    projectId: input.reservation.projectId,
-    workDayId: input.reservation.workDayId,
-    taskId: input.reservation.taskId,
-    phase: "reservation_released",
-    credits: -credits,
-    source: input.source ?? "capacity_coordinator",
-    metadata: input.metadata ?? {}
-  };
-}
-function settleCapacityActuals(input) {
-  const consumedCredits = Math.max(0, Number(input.actualCredits ?? 0));
-  const releasedCredits = Math.max(0, input.reservation.reservedCredits - consumedCredits);
-  const overrunCredits = Math.max(0, consumedCredits - input.reservation.reservedCredits);
-  const base = {
-    capacityProviderId: input.reservation.capacityProviderId,
-    laneId: input.reservation.laneId,
-    reservationId: input.reservation.id,
-    teamId: input.teamId ?? input.reservation.teamId,
-    projectId: input.projectId ?? input.reservation.projectId,
-    workDayId: input.workDayId ?? input.reservation.workDayId,
-    taskId: input.taskId ?? input.reservation.taskId,
-    source: input.source ?? "capacity_coordinator",
-    metadata: input.metadata ?? {}
-  };
-  const consumeEntry = {
-    ...base,
-    phase: "task_completed_actual_settlement",
-    credits: consumedCredits,
-    providerUnits: input.actualProviderUnits ?? null,
-    usd: input.actualUsd ?? null
-  };
-  const releaseEntry = releasedCredits > 0 ? {
-    ...base,
-    phase: "reservation_released",
-    credits: -releasedCredits
-  } : null;
-  const overrunEntry = overrunCredits > 0 ? {
-    ...base,
-    phase: "overrun_hold",
-    credits: overrunCredits
-  } : null;
-  return {
-    reservationId: input.reservation.id,
-    state: overrunCredits > 0 ? "overran_pending_approval" : "consumed",
-    consumeEntry,
-    releaseEntry,
-    overrunEntry,
-    consumedCredits,
-    releasedCredits,
-    overrunCredits
-  };
-}
-function distinctProfiles(profiles) {
-  const seen = /* @__PURE__ */ new Set();
-  return profiles.filter((profile) => {
-    if (seen.has(profile.id)) return false;
-    seen.add(profile.id);
-    return true;
-  });
-}
-function executionProfilesForRoute(input) {
-  const explicitProfiles = Array.isArray(input.executionProfiles) && input.executionProfiles.length > 0 ? input.executionProfiles : null;
-  const preferred = stringArray(input.preferredExecutionProfiles);
-  const disallowed = new Set(stringArray(input.disallowedExecutionProfiles));
-  const rawProfiles = explicitProfiles ?? (preferred.length > 0 ? preferred : input.executionProfile ? [input.executionProfile] : input.estimate.executionProfileId ? [input.estimate.executionProfileId] : [DEFAULT_EXECUTION_PROFILE_ID]);
-  const profiles = distinctProfiles(rawProfiles.map((profile) => normalizeExecutionProfile(profile))).filter((profile) => !disallowed.has(profile.id));
-  return profiles.length > 0 ? profiles : [normalizeExecutionProfile(DEFAULT_EXECUTION_PROFILE_ID)];
-}
-function estimateForRouteProfile(input, profile) {
-  const selectedProfile = selectTaskEstimateProfile({
-    profiles: input.estimateProfiles ?? input.plan.estimateProfiles ?? null,
-    taskSignature: input.estimate.taskSignature,
-    executionProfile: profile,
-    executionProfileId: profile.id
-  });
-  return reserveCreditsForEstimate({
-    taskSignature: input.estimate.taskSignature,
-    taskKind: input.taskKind ?? input.estimate.taskSignature,
-    confidence: input.estimate.confidence ?? input.classification?.confidence ?? "medium",
-    estimatedCreditsP50: selectedProfile ? void 0 : input.estimate.estimatedCreditsP50,
-    estimatedCreditsP90: selectedProfile ? void 0 : input.estimate.estimatedCreditsP90,
-    defaultCredits: input.estimate.estimatedCreditsP50,
-    profiles: input.estimateProfiles ?? input.plan.estimateProfiles ?? null,
-    profile: selectedProfile,
-    executionProfile: profile,
-    executionProfileId: profile.id
-  });
-}
-function routeMinimumQuality(input) {
-  const explicit = finiteOrParsedNumber(input.minimumQualityWeight);
-  if (explicit !== null) return Math.max(0, explicit);
-  if (input.production || input.classification?.mutationScope === "production") return 1.5;
-  if (input.classification?.risk === "high" || input.classification?.requiresApproval) return 1.25;
-  if (input.classification?.confidence === "low") return 1.1;
-  return 0;
-}
-function routeRequiredContext(input) {
-  return Math.max(0, finiteOrParsedNumber(input.requiredContextTokens) ?? 0);
-}
-function reservationMetadata(reservation) {
-  return readRecord(reservation.metadata);
-}
-function attentionValueFromMetadata(metadata, ...keys) {
-  const estimate = readRecord(metadata.attentionEstimate);
-  for (const key of keys) {
-    const value = finiteOrParsedNumber(metadata[key]) ?? finiteOrParsedNumber(estimate[key]);
-    if (value !== null) return value;
-  }
-  return null;
-}
-function activeLaneReservations(plan, provider, lane) {
-  return plan.activeReservations.filter(
-    (reservation) => reservation.capacityProviderId === provider.id && (!lane || reservation.laneId === lane.id) && (reservation.state === "reserved" || reservation.state === "consuming")
-  );
-}
-function attentionLimitNumber(lane, provider, key) {
-  return finiteOrParsedNumber(lane.hardLimits?.[key]) ?? finiteOrParsedNumber(lane.routingPolicy?.[key]) ?? finiteOrParsedNumber(lane.metadata?.[key]) ?? finiteOrParsedNumber(readRecord(lane.metadata?.pressure)[key]) ?? finiteOrParsedNumber(provider.capacityModel?.[key]) ?? finiteOrParsedNumber(provider.metadata?.[key]) ?? finiteOrParsedNumber(readRecord(provider.metadata?.pressure)[key]);
-}
-function deriveAttentionWeight(classification, profile, contextTokens) {
-  let weight = 1;
-  const mutationScope = classification?.mutationScope ?? "repository_read";
-  if (mutationScope === "repository_read") weight = 1.5;
-  if (mutationScope === "repository_write") weight = 3;
-  if (mutationScope === "production") weight = 6;
-  if (classification?.risk === "medium") weight += 1;
-  if (classification?.risk === "high") weight += 3;
-  if (classification?.confidence === "low") weight += 1;
-  weight += Math.max(0, classification?.expectedFanout ?? 0) * 0.5;
-  if (profile.concurrencyClass === "human_attention" || profile.quotaBehavior === "attention_bound") weight += 5;
-  if (profile.concurrencyClass === "exclusive_project") weight += 3;
-  if (contextTokens >= 1e5) weight += 4;
-  else if (contextTokens >= 32e3) weight += 2;
-  return Math.max(0, weight);
-}
-function estimateAttentionForTask(input) {
-  const profile = normalizeExecutionProfile(input.executionProfile);
-  const policy = normalizeAttentionPolicy(input.attentionPolicy);
-  const requiredContextTokens = Math.max(0, finiteOrParsedNumber(input.requiredContextTokens) ?? 0);
-  const estimatedContextTokens = Math.max(requiredContextTokens, finiteOrParsedNumber(input.estimatedContextTokens) ?? requiredContextTokens);
-  const baseAttention = finiteOrParsedNumber(input.attentionWeight) ?? deriveAttentionWeight(input.classification, profile, estimatedContextTokens);
-  const coordinationWeight = finiteOrParsedNumber(input.coordinationWeight) ?? Math.max(0, input.classification?.expectedFanout ?? 0) * policy.coordinationOverheadFactor;
-  return {
-    attentionWeight: Math.max(0, Math.ceil(baseAttention * 100) / 100),
-    coordinationWeight: Math.max(0, Math.ceil(coordinationWeight * 100) / 100),
-    totalAttentionWeight: Math.max(0, Math.ceil((baseAttention + coordinationWeight) * 100) / 100),
-    estimatedContextTokens,
-    requiredContextTokens,
-    source: input.source ?? "capacity_attention_estimator",
-    metadata: input.metadata ?? {}
-  };
-}
-function attentionEstimateForRoute(input, profile) {
-  if (input.attentionEstimate) return input.attentionEstimate;
-  return estimateAttentionForTask({
-    classification: input.classification,
-    executionProfile: profile,
-    attentionPolicy: input.attentionPolicy,
-    attentionWeight: input.attentionWeight,
-    coordinationWeight: input.coordinationWeight,
-    estimatedContextTokens: input.estimatedContextTokens,
-    requiredContextTokens: input.requiredContextTokens,
-    source: input.source ?? "capacity_router"
-  });
-}
-function readPressureNumber(provider, lane, key) {
-  const laneValue = finiteOrParsedNumber(lane.metadata?.[key]);
-  if (laneValue !== null) return laneValue;
-  const providerValue = finiteOrParsedNumber(provider.metadata?.[key]);
-  if (providerValue !== null) return providerValue;
-  const lanePressure = readRecord(lane.metadata?.pressure);
-  const providerPressure = readRecord(provider.metadata?.pressure);
-  return finiteOrParsedNumber(lanePressure[key]) ?? finiteOrParsedNumber(providerPressure[key]);
-}
-function readPressureBoolean(provider, lane, key) {
-  const values = [
-    lane.metadata?.[key],
-    provider.metadata?.[key],
-    readRecord(lane.metadata?.pressure)[key],
-    readRecord(provider.metadata?.pressure)[key]
-  ];
-  return values.some((value) => value === true || value === "true");
-}
-function hardLimitNumber(lane, provider, ...keys) {
-  for (const key of keys) {
-    const value = finiteOrParsedNumber(lane.hardLimits?.[key]) ?? finiteOrParsedNumber(lane.routingPolicy?.[key]) ?? finiteOrParsedNumber(provider.capacityModel?.[key]) ?? finiteOrParsedNumber(provider.metadata?.[key]);
-    if (value !== null && value >= 0) return value;
-  }
-  return null;
-}
-function capacityRoutePressure(plan, provider, lane) {
-  const reservations = activeLaneReservations(plan, provider, lane);
-  const activeReservations = reservations.length;
-  const maxActiveReservations = hardLimitNumber(
-    lane,
-    provider,
-    "maxActiveReservations",
-    "maxConcurrentTasks",
-    "maxConcurrentWorkers"
-  ) ?? (provider.maxConcurrentWorkers > 0 ? provider.maxConcurrentWorkers : null);
-  const congestionRatio = maxActiveReservations && maxActiveReservations > 0 ? activeReservations / maxActiveReservations : 0;
-  const activeAttentionLoad = reservations.reduce((total, reservation) => {
-    const metadata = reservationMetadata(reservation);
-    return total + Math.max(0, attentionValueFromMetadata(metadata, "totalAttentionWeight", "attentionWeight") ?? 0);
-  }, 0);
-  const maxAttentionLoad = attentionLimitNumber(lane, provider, "maxAttentionLoad");
-  const activeContextTokens = reservations.reduce((total, reservation) => {
-    const metadata = reservationMetadata(reservation);
-    return total + Math.max(0, attentionValueFromMetadata(metadata, "estimatedContextTokens", "contextTokens", "requiredContextTokens") ?? 0);
-  }, 0);
-  const maxContextTokens = attentionLimitNumber(lane, provider, "maxContextTokens");
-  return {
-    activeReservations,
-    maxActiveReservations,
-    congestionRatio,
-    quotaRemainingPercent: readPressureNumber(provider, lane, "quotaRemainingPercent"),
-    sessionRemainingMinutes: readPressureNumber(provider, lane, "sessionRemainingMinutes"),
-    subscriptionSaturationPercent: readPressureNumber(provider, lane, "subscriptionSaturationPercent"),
-    providerUnavailable: readPressureBoolean(provider, lane, "providerUnavailable"),
-    activeAttentionLoad,
-    maxAttentionLoad,
-    attentionSaturationPercent: maxAttentionLoad && maxAttentionLoad > 0 ? activeAttentionLoad / maxAttentionLoad * 100 : null,
-    activeContextTokens,
-    maxContextTokens,
-    contextSaturationPercent: maxContextTokens && maxContextTokens > 0 ? activeContextTokens / maxContextTokens * 100 : null
-  };
-}
-function latencyPenalty(profile) {
-  if (profile.latencyClass === "high") return 12;
-  if (profile.latencyClass === "medium") return 5;
-  return 0;
-}
-function quotaPressurePenalty(pressure) {
-  let penalty = 0;
-  if (pressure.quotaRemainingPercent !== null) {
-    penalty += Math.max(0, 100 - pressure.quotaRemainingPercent) * 0.25;
-  }
-  if (pressure.subscriptionSaturationPercent !== null) {
-    penalty += Math.max(0, pressure.subscriptionSaturationPercent) * 0.35;
-  }
-  if (pressure.sessionRemainingMinutes !== null && pressure.sessionRemainingMinutes < 20) {
-    penalty += (20 - pressure.sessionRemainingMinutes) * 1.5;
-  }
-  return penalty;
-}
-function attentionPressurePenalty(pressure, estimate, policy) {
-  if (!pressure.maxAttentionLoad || pressure.maxAttentionLoad <= 0) return 0;
-  const allocatableLoad = Math.max(0, pressure.maxAttentionLoad * (1 - policy.reserveAttentionPercent / 100));
-  const projected = pressure.activeAttentionLoad + estimate.totalAttentionWeight;
-  const saturation = allocatableLoad > 0 ? projected / allocatableLoad : 1;
-  return Math.max(0, saturation) * 35;
-}
-function contextPressurePenalty(pressure, estimate, policy) {
-  const maxContextTokens = pressure.maxContextTokens ?? policy.maxContextTokens;
-  if (!maxContextTokens || maxContextTokens <= 0) return 0;
-  const projected = pressure.activeContextTokens + estimate.estimatedContextTokens;
-  const saturationPercent = projected / maxContextTokens * 100;
-  return Math.max(0, saturationPercent - 50) * 0.6;
-}
-function laneSupportsExecutionProfile(lane, profile) {
-  const allowedProfiles = stringArray(lane.routingPolicy?.executionProfiles);
-  if (allowedProfiles.length > 0 && !allowedProfiles.includes(profile.id)) return false;
-  const allowedModelClasses = stringArray(lane.routingPolicy?.modelClasses);
-  if (allowedModelClasses.length > 0 && profile.modelClass && !allowedModelClasses.includes(profile.modelClass)) return false;
-  return true;
-}
-function routeTrustScore(provider, lane, profile) {
-  const laneMetadata = readRecord(lane.metadata);
-  const providerMetadata = readRecord(provider.metadata);
-  const profileMetadata = readRecord(profile.metadata);
-  const trust = finiteOrParsedNumber(laneMetadata.trustScore) ?? finiteOrParsedNumber(providerMetadata.trustScore) ?? finiteOrParsedNumber(profileMetadata.trustScore) ?? 1;
-  const availability = finiteOrParsedNumber(laneMetadata.availabilityScore) ?? finiteOrParsedNumber(providerMetadata.availabilityScore) ?? 1;
-  return Math.max(0, Math.min(1, trust)) * Math.max(0, Math.min(1, availability));
-}
-function routeSuccessProbability(input) {
-  const laneMetadata = readRecord(input.lane.metadata);
-  const providerMetadata = readRecord(input.provider.metadata);
-  const profileMetadata = readRecord(input.profile.metadata);
-  const success = finiteOrParsedNumber(input.explicit) ?? finiteOrParsedNumber(laneMetadata.successProbability) ?? finiteOrParsedNumber(providerMetadata.successProbability) ?? finiteOrParsedNumber(profileMetadata.successProbability) ?? input.utilityEstimate.successProbability ?? 1;
-  return Math.max(0, Math.min(1, success));
-}
-function routePriceMultiplier(provider, lane, profile) {
-  const laneMetadata = readRecord(lane.metadata);
-  const providerMetadata = readRecord(provider.metadata);
-  const profileMetadata = readRecord(profile.metadata);
-  return Math.max(0.1, finiteOrParsedNumber(laneMetadata.priceMultiplier) ?? finiteOrParsedNumber(providerMetadata.priceMultiplier) ?? finiteOrParsedNumber(profileMetadata.priceMultiplier) ?? 1);
-}
-function capacityBudgetMode(provider) {
-  const mode = String(provider.creditBudgetMode ?? "derived").toLowerCase();
-  if (mode === "static" || mode === "hybrid" || mode === "derived") return mode;
-  return "derived";
-}
-function routeDerivedEntries(plan) {
-  const seen = /* @__PURE__ */ new Set();
-  const entries = [];
-  const add = (entry) => {
-    if (!entry) return;
-    const key = `${entry.executionProviderId}:${entry.nativeUnit}:${entry.scope ?? ""}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    entries.push(entry);
-  };
-  for (const entry of plan.derivedCapacity?.entries ?? []) add(entry);
-  for (const summary of plan.derivedCapacity?.providers ?? []) {
-    for (const entry of summary.entries ?? []) add(entry);
-  }
-  return entries;
-}
-function routeDerivedHints(provider, lane, profile) {
-  const providerMetadata = readRecord(provider.metadata);
-  const laneMetadata = readRecord(lane.metadata);
-  const profileMetadata = readRecord(profile.metadata);
-  return {
-    executionProviderId: stringValue(laneMetadata.executionProviderId) ?? stringValue(providerMetadata.executionProviderId) ?? stringValue(profileMetadata.executionProviderId),
-    executionProviderKind: stringValue(laneMetadata.executionProviderKind) ?? stringValue(laneMetadata.providerKind) ?? stringValue(providerMetadata.executionProviderKind) ?? stringValue(providerMetadata.providerKind) ?? stringValue(profileMetadata.executionProviderKind),
-    nativeUnit: stringValue(laneMetadata.nativeUnit) ?? stringValue(providerMetadata.nativeUnit) ?? stringValue(profileMetadata.nativeUnit)
-  };
-}
-function selectDerivedCapacityForRoute(plan, provider, lane, profile) {
-  const hints = routeDerivedHints(provider, lane, profile);
-  const entries = routeDerivedEntries(plan).filter((entry) => entry.capacityProviderId === provider.id || entry.capacityProviderId === null).filter((entry) => !hints.executionProviderId || entry.executionProviderId === hints.executionProviderId).filter((entry) => !hints.executionProviderKind || entry.executionProviderKind === hints.executionProviderKind).filter((entry) => !hints.nativeUnit || entry.nativeUnit === hints.nativeUnit);
-  return entries.sort((left, right) => {
-    const leftExact = (hints.executionProviderId && left.executionProviderId === hints.executionProviderId ? 20 : 0) + (hints.executionProviderKind && left.executionProviderKind === hints.executionProviderKind ? 10 : 0) + (hints.nativeUnit && left.nativeUnit === hints.nativeUnit ? 5 : 0);
-    const rightExact = (hints.executionProviderId && right.executionProviderId === hints.executionProviderId ? 20 : 0) + (hints.executionProviderKind && right.executionProviderKind === hints.executionProviderKind ? 10 : 0) + (hints.nativeUnit && right.nativeUnit === hints.nativeUnit ? 5 : 0);
-    return rightExact - leftExact || derivedConfidenceRank(right.confidence) - derivedConfidenceRank(left.confidence) || Number(left.derivedAvailableCredits ?? Number.POSITIVE_INFINITY) - Number(right.derivedAvailableCredits ?? Number.POSITIVE_INFINITY) || Number(left.availableNativeAmount ?? Number.POSITIVE_INFINITY) - Number(right.availableNativeAmount ?? Number.POSITIVE_INFINITY) || `${left.executionProviderId}:${left.nativeUnit}`.localeCompare(`${right.executionProviderId}:${right.nativeUnit}`);
-  })[0] ?? null;
-}
-function roundUpNativeAmount(value) {
-  if (!Number.isFinite(value) || value <= 0) return 0;
-  return Math.ceil(value * 1e3) / 1e3;
-}
-function nativePressureForRoute(entry, estimate) {
-  if (!entry) return null;
-  const reservedNativeAmount = entry.nativeUnitsPerCredit && entry.nativeUnitsPerCredit > 0 ? roundUpNativeAmount(estimate.reservedCredits * entry.nativeUnitsPerCredit) : null;
-  const pressureRatio = reservedNativeAmount !== null && entry.availableNativeAmount > 0 ? reservedNativeAmount / entry.availableNativeAmount : entry.availableNativeAmount <= 0 ? 1 : null;
-  return {
-    executionProviderId: entry.executionProviderId,
-    nativeUnit: entry.nativeUnit,
-    availableNativeAmount: entry.availableNativeAmount,
-    activeReservedNativeAmount: entry.activeReservedNativeAmount,
-    reserveBufferNativeAmount: entry.reserveBufferNativeAmount,
-    reservedNativeAmount,
-    pressureRatio,
-    confidence: entry.confidence,
-    reasons: entry.reasons
-  };
-}
-function derivedRouteBudget(input) {
-  const reasons = [];
-  const derivedCredits = input.derivedCapacity?.derivedAvailableCredits ?? null;
-  const confidenceRank = derivedConfidenceRank(input.derivedCapacity?.confidence);
-  const hasUsableDerived = Boolean(input.derivedCapacity && derivedCredits !== null && confidenceRank >= 2);
-  const portfolioPercent = grantPortfolioAllocationPercent(input.grant);
-  let remainingCredits = input.staticRemainingCredits;
-  let appliesDerived = false;
-  if (input.mode === "derived") {
-    appliesDerived = true;
-    if (!input.derivedCapacity) {
-      reasons.push("missing_derived_capacity", "insufficient_budget");
-      return { remainingCredits: null, appliesDerived, hasUsableDerived: false, reasons };
-    }
-    if (derivedCredits === null) {
-      reasons.push("missing_conversion_profile", "insufficient_budget");
-      return { remainingCredits: null, appliesDerived, hasUsableDerived: false, reasons };
-    }
-    if (confidenceRank < 2) {
-      reasons.push("derived_capacity_learning", "insufficient_budget");
-      return { remainingCredits: derivedCredits, appliesDerived, hasUsableDerived: false, reasons };
-    }
-    remainingCredits = input.staticRemainingCredits === null ? derivedCredits : Math.min(input.staticRemainingCredits, derivedCredits);
-    reasons.push("derived_capacity_available");
-    if (portfolioPercent !== null) reasons.push("portfolio_allocation_applied");
-  } else if (input.mode === "hybrid") {
-    if (hasUsableDerived) {
-      appliesDerived = true;
-      remainingCredits = input.staticRemainingCredits === null ? derivedCredits : Math.min(input.staticRemainingCredits, derivedCredits);
-      reasons.push("hybrid_derived_capacity_applied");
-      if (portfolioPercent !== null) reasons.push("portfolio_allocation_applied");
-      if (input.staticRemainingCredits !== null && input.staticRemainingCredits <= derivedCredits) {
-        reasons.push("hybrid_static_cap_applied");
-      }
-    } else if (input.derivedCapacity && derivedCredits !== null && confidenceRank < 2) {
-      reasons.push("derived_capacity_learning");
-    } else if (input.derivedCapacity && derivedCredits === null) {
-      reasons.push("missing_conversion_profile");
-    }
-  }
-  if (appliesDerived && hasUsableDerived && derivedCredits !== null && derivedCredits < input.estimate.reservedCredits) {
-    reasons.push("derived_capacity_exhausted");
-    if (input.grant.overflowPolicy === "approval_required") {
-      reasons.push("approval_required");
-    } else if (input.grant.overflowPolicy === "fallback_lane") {
-      reasons.push("fallback_lane_exhausted");
-    } else if (input.grant.overflowPolicy === "deny" || input.grant.overflowPolicy === "hard_grant" || input.mode === "derived") {
-      reasons.push("insufficient_budget");
-    } else {
-      reasons.push("soft_budget_pressure", "derived_capacity_pressure");
-    }
-  }
-  return { remainingCredits, appliesDerived, hasUsableDerived, reasons };
-}
-function routeScore(input) {
-  const reasons = [...input.baseScore.reasons];
-  const qualityFit = input.minimumQualityWeight > 0 ? input.profile.qualityWeight / input.minimumQualityWeight : input.profile.qualityWeight;
-  const qualityBonus = Math.min(50, Math.max(0, input.profile.qualityWeight * 20));
-  const costPenalty = Math.max(0, input.estimate.reservedCredits);
-  const latency = latencyPenalty(input.profile);
-  const congestion = input.pressure.congestionRatio * 45;
-  const quota = quotaPressurePenalty(input.pressure);
-  const attention = attentionPressurePenalty(input.pressure, input.attentionEstimate, input.attentionPolicy);
-  const context = contextPressurePenalty(input.pressure, input.attentionEstimate, input.attentionPolicy);
-  const priceMultiplier = routePriceMultiplier(input.provider, input.lane, input.profile);
-  const utilityBonus = input.utilityEstimate.utilityScore > 0 ? Math.min(100, input.utilityEstimate.utilityPerCredit * 18 * Math.max(0.1, input.trustScore) * Math.max(0.1, input.successProbability)) : 0;
-  const cooperativeBonus = input.cooperativeRouting ? input.trustScore * 20 + input.successProbability * 15 : 0;
-  const predictedReserveImpact = input.reservePrediction?.reserveCredits ?? 0;
-  const laneModelFit = input.profile.modelClass && input.lane.modelClass === input.profile.modelClass ? 15 : 0;
-  const riskBonus = input.minimumQualityWeight >= 1.25 && input.profile.qualityWeight >= input.minimumQualityWeight ? 10 : 0;
-  const nativePressurePenalty = input.nativePressure?.pressureRatio !== null && input.nativePressure?.pressureRatio !== void 0 ? Math.max(0, input.nativePressure.pressureRatio) * 35 : 0;
-  const score = input.baseScore.score + qualityBonus + laneModelFit + riskBonus + utilityBonus + cooperativeBonus - costPenalty - latency - congestion - quota - attention - context - nativePressurePenalty - Math.max(0, priceMultiplier - 1) * 8 - (input.reservePrediction && input.reservePrediction.reservePercent > 0 ? Math.min(20, predictedReserveImpact * 0.25) : 0);
-  if (laneModelFit > 0) reasons.push("execution_profile_model_class_match");
-  if (congestion > 0) reasons.push("lane_congestion_pressure");
-  if (quota > 0) reasons.push("quota_pressure");
-  if (attention > 0) reasons.push("attention_pressure");
-  if (context > 0) reasons.push("context_pressure");
-  if (nativePressurePenalty > 0) reasons.push("native_capacity_pressure");
-  if (utilityBonus > 0) reasons.push("utility_scored");
-  if (cooperativeBonus > 0) reasons.push("cooperative_route_scored");
-  if (predictedReserveImpact > 0) reasons.push("predictive_reserve_applied");
-  return {
-    ...input.baseScore,
-    score,
-    qualityFit,
-    latencyPenalty: latency,
-    quotaPressure: quota,
-    congestionPenalty: congestion,
-    attentionPenalty: attention,
-    contextPenalty: context,
-    nativePressurePenalty,
-    utilityScore: input.utilityEstimate.utilityScore,
-    utilityPerCredit: input.utilityEstimate.utilityPerCredit,
-    predictedReserveImpact,
-    trustScore: input.trustScore,
-    successProbability: input.successProbability,
-    costPenalty,
-    executionProfileId: input.profile.id,
-    reservedCredits: input.estimate.reservedCredits,
-    attentionEstimate: input.attentionEstimate,
-    reasons: [...new Set(reasons)]
-  };
-}
-function routeCandidateKey(candidate) {
-  return `${candidate.providerId}:${candidate.laneId}:${candidate.grantId}:${candidate.executionProfileId ?? DEFAULT_EXECUTION_PROFILE_ID}`;
-}
-function routeAndReserveCapacity(input) {
-  const providers = input.plan.providers.filter((provider2) => providerIsEligible(provider2, input));
-  const grants = input.plan.grants.filter((grant2) => grantIsEligible(grant2, input));
-  const candidates = [];
-  const executionProfiles = executionProfilesForRoute(input);
-  const minimumQualityWeight = routeMinimumQuality(input);
-  const requiredContextTokens = routeRequiredContext(input);
-  const attentionPolicy = normalizeAttentionPolicy(input.attentionPolicy);
-  const utilityPolicy = normalizeUtilityPolicy(input.utilityPolicy);
-  const predictiveReservePolicy = normalizePredictiveReservePolicy(input.predictiveReservePolicy);
-  const hybridExecutionPlan = normalizeHybridExecutionPlan(input.hybridExecutionPlan ?? readRecord(input.metadata).hybridExecutionPlan);
-  const preferredProfiles = new Set(stringArray(input.preferredExecutionProfiles));
-  const disallowedProfiles = new Set(stringArray(input.disallowedExecutionProfiles));
-  const cooperativeRouting = input.cooperativeRouting === true || readRecord(input.metadata).cooperativeRouting === true;
-  const trustRequirement = finiteOrParsedNumber(input.trustRequirement);
-  for (const grant2 of grants) {
-    const provider2 = providers.find((candidate) => candidate.id === grant2.capacityProviderId);
-    if (!provider2) continue;
-    const lanes = input.plan.lanes.filter(
-      (lane2) => lane2.capacityProviderId === provider2.id && (!grant2.laneId || grant2.laneId === lane2.id)
-    );
-    for (const lane2 of lanes) {
-      const pressure = capacityRoutePressure(input.plan, provider2, lane2);
-      for (const profile of executionProfiles) {
-        const estimate = estimateForRouteProfile(input, profile);
-        const derivedCapacityMode = capacityBudgetMode(provider2);
-        const derivedCapacity = derivedCapacityMode === "static" ? null : selectDerivedCapacityForRoute(input.plan, provider2, lane2, profile);
-        const staticRemainingCredits = grantRemainingCredits(input.plan, grant2, derivedCapacity, input);
-        const routeBudget = derivedRouteBudget({
-          mode: derivedCapacityMode,
-          staticRemainingCredits,
-          derivedCapacity,
-          estimate,
-          grant: grant2
-        });
-        const remainingCredits = routeBudget.remainingCredits;
-        const nativePressure = nativePressureForRoute(derivedCapacity, estimate);
-        const attentionEstimate = attentionEstimateForRoute(input, profile);
-        const utilityEstimate = input.utilityEstimate ?? estimateUtilityForTask({
-          classification: input.classification,
-          executionProfile: profile,
-          estimate,
-          utilityPolicy,
-          utilityValue: input.utilityValue,
-          maintenanceValue: input.maintenanceValue,
-          priority: finiteOrParsedNumber(readRecord(input.metadata).priority),
-          deadlineAt: input.deadlineAt ?? (typeof readRecord(input.metadata).deadlineAt === "string" ? readRecord(input.metadata).deadlineAt : null),
-          successProbability: input.successProbability,
-          metadata: input.metadata,
-          source: input.source ?? "capacity_router"
-        });
-        const reservePrediction = predictReserveForCapacityPlan({
-          plan: input.plan,
-          policy: predictiveReservePolicy,
-          remainingCredits,
-          metadata: input.metadata
-        });
-        const trustScore = routeTrustScore(provider2, lane2, profile);
-        const successProbability = routeSuccessProbability({
-          provider: provider2,
-          lane: lane2,
-          profile,
-          explicit: input.successProbability,
-          utilityEstimate
-        });
-        const estimateInput = { ...input, estimate };
-        const reasons = [...routeBudget.reasons, ...lanePolicyReasons(lane2, estimateInput)];
-        let spilloverReason = null;
-        if (trustRequirement !== null && trustScore < trustRequirement) reasons.push("trust_below_requirement");
-        if (utilityPolicy.minimumUtilityScore !== null && utilityEstimate.utilityScore < utilityPolicy.minimumUtilityScore) reasons.push("utility_below_minimum");
-        if (utilityPolicy.minimumUtilityPerCredit !== null && utilityEstimate.utilityPerCredit < utilityPolicy.minimumUtilityPerCredit) reasons.push("utility_per_credit_below_minimum");
-        if (predictiveReservePolicy.enabled && reservePrediction.reserveCredits > 0 && reservePrediction.activelyAllocatableCredits < estimate.reservedCredits && utilityEstimate.utilityScore < 50) {
-          reasons.push("predictive_reserve_blocked");
-        }
-        const routeMaxAttentionLoad = attentionPolicy.maxAttentionLoad ?? pressure.maxAttentionLoad;
-        if (routeMaxAttentionLoad !== null && routeMaxAttentionLoad > 0) {
-          const allocatableAttention = Math.max(0, routeMaxAttentionLoad * (1 - attentionPolicy.reserveAttentionPercent / 100));
-          const projectedAttention = pressure.activeAttentionLoad + attentionEstimate.totalAttentionWeight;
-          if (projectedAttention > allocatableAttention) reasons.push("attention_load_exceeded");
-          const availableAttention = Math.max(0, allocatableAttention - pressure.activeAttentionLoad);
-          const minimumAttentionAvailable = finiteOrParsedNumber(input.minimumAttentionAvailable);
-          if (minimumAttentionAvailable !== null && availableAttention < minimumAttentionAvailable) reasons.push("minimum_attention_unavailable");
-        }
-        const routeMaxContextTokens = attentionPolicy.maxContextTokens ?? pressure.maxContextTokens;
-        if (routeMaxContextTokens !== null && routeMaxContextTokens > 0) {
-          const projectedContextTokens = pressure.activeContextTokens + attentionEstimate.estimatedContextTokens;
-          const projectedSaturation = projectedContextTokens / routeMaxContextTokens * 100;
-          if (projectedContextTokens > routeMaxContextTokens || projectedSaturation > attentionPolicy.maxContextSaturationPercent) {
-            reasons.push("context_saturation_exceeded");
-          }
-        }
-        if (disallowedProfiles.has(profile.id)) reasons.push("execution_profile_disallowed");
-        if (preferredProfiles.size > 0 && !preferredProfiles.has(profile.id)) reasons.push("execution_profile_not_preferred");
-        if (!laneSupportsExecutionProfile(lane2, profile)) reasons.push("execution_profile_not_supported");
-        if (minimumQualityWeight > 0 && profile.qualityWeight < minimumQualityWeight) reasons.push("quality_below_minimum");
-        if (requiredContextTokens > 0 && profile.contextWindowTokens !== null && profile.contextWindowTokens !== void 0 && profile.contextWindowTokens < requiredContextTokens) {
-          reasons.push("context_window_too_small");
-        }
-        if (pressure.providerUnavailable) reasons.push("provider_unavailable");
-        if (pressure.maxActiveReservations !== null && pressure.congestionRatio >= 1) reasons.push("lane_congested");
-        if (pressure.quotaRemainingPercent !== null && pressure.quotaRemainingPercent <= 0) reasons.push("quota_exhausted");
-        if (pressure.sessionRemainingMinutes !== null && pressure.sessionRemainingMinutes <= 0) reasons.push("session_exhausted");
-        if (remainingCredits !== null && remainingCredits < estimate.reservedCredits) {
-          if (grantPortfolioAllocationPercent(grant2) !== null) reasons.push("portfolio_allocation_exhausted");
-          if (grant2.overflowPolicy === "approval_required") {
-            reasons.push("approval_required");
-          } else if (grant2.overflowPolicy === "fallback_lane") {
-            spilloverReason = "fallback_lane";
-            reasons.push("fallback_lane_exhausted");
-          } else if (grant2.overflowPolicy === "deny" || grant2.overflowPolicy === "hard_grant") {
-            reasons.push("insufficient_budget");
-          } else {
-            reasons.push("soft_budget_pressure");
-          }
-        }
-        const baseScore = scoreCapacityLane({
-          lane: lane2,
-          grant: grant2,
-          remainingCredits,
-          taskKind: input.taskKind ?? estimate.taskSignature,
-          requiredCapabilities: input.requiredCapabilities,
-          modelClass: input.modelClass ?? profile.modelClass ?? null
-        });
-        const score = routeScore({
-          provider: provider2,
-          lane: lane2,
-          grant: grant2,
-          estimate,
-          profile,
-          remainingCredits,
-          pressure,
-          minimumQualityWeight,
-          attentionEstimate,
-          attentionPolicy,
-          utilityEstimate,
-          reservePrediction,
-          trustScore,
-          successProbability,
-          cooperativeRouting,
-          baseScore,
-          nativePressure
-        });
-        candidates.push({
-          providerId: provider2.id,
-          laneId: lane2.id,
-          grantId: grant2.id,
-          executionProviderId: routeBudget.appliesDerived && routeBudget.hasUsableDerived ? derivedCapacity?.executionProviderId ?? null : null,
-          executionProfileId: profile.id,
-          nativeUnit: routeBudget.appliesDerived && routeBudget.hasUsableDerived ? derivedCapacity?.nativeUnit ?? null : null,
-          remainingCredits,
-          staticRemainingCredits,
-          derivedAvailableCredits: derivedCapacity?.derivedAvailableCredits ?? null,
-          reservedNativeAmount: routeBudget.appliesDerived && routeBudget.hasUsableDerived ? nativePressure?.reservedNativeAmount ?? null : null,
-          derivedCapacity: derivedCapacity ?? null,
-          derivedCapacityMode,
-          score,
-          eligible: reasons.filter(
-            (reason) => reason !== "soft_budget_pressure" && reason !== "execution_profile_not_preferred" && reason !== "derived_capacity_available" && reason !== "hybrid_derived_capacity_applied" && reason !== "hybrid_static_cap_applied" && reason !== "portfolio_allocation_applied" && reason !== "derived_capacity_learning" && reason !== "missing_conversion_profile"
-          ).length === 0,
-          reasons: [.../* @__PURE__ */ new Set([...reasons, ...score.reasons])],
-          estimate,
-          pressure,
-          nativePressure,
-          qualityFit: score.qualityFit,
-          attentionEstimate,
-          utilityEstimate,
-          reservePrediction,
-          trustScore,
-          successProbability,
-          spilloverReason
-        });
-      }
-    }
-  }
-  if (input.plan.providers.length === 0 || providers.length === 0) {
-    return {
-      ok: false,
-      code: "no_capacity_provider",
-      reason: "No active helper capacity provider is available.",
-      estimate: input.estimate,
-      candidates
-    };
-  }
-  if (grants.length === 0) {
-    return {
-      ok: false,
-      code: "no_capacity_grant",
-      reason: "No active capacity grant is available for this team, project, and environment.",
-      estimate: input.estimate,
-      candidates
-    };
-  }
-  const eligible = candidates.filter((candidate) => candidate.eligible).sort(
-    (left, right) => right.score.score - left.score.score || (left.estimate?.reservedCredits ?? Number.MAX_SAFE_INTEGER) - (right.estimate?.reservedCredits ?? Number.MAX_SAFE_INTEGER) || routeCandidateKey(left).localeCompare(routeCandidateKey(right))
-  );
-  const selected = eligible[0] ?? null;
-  if (!selected) {
-    const hasApprovalBlock = candidates.some((candidate) => candidate.reasons.includes("approval_required"));
-    const hasBudgetBlock = candidates.some((candidate) => candidate.reasons.includes("insufficient_budget"));
-    return {
-      ok: false,
-      code: hasApprovalBlock ? "approval_required" : hasBudgetBlock ? "insufficient_budget" : "no_eligible_lane",
-      reason: hasApprovalBlock ? "The requested helper task needs approval before capacity can be reserved." : hasBudgetBlock ? "The requested helper task is above the remaining approved budget." : "No provider lane matches the task policy and capability requirements.",
-      estimate: input.estimate,
-      candidates
-    };
-  }
-  const provider = providers.find((candidate) => candidate.id === selected.providerId);
-  const lane = input.plan.lanes.find((candidate) => candidate.id === selected.laneId);
-  const grant = grants.find((candidate) => candidate.id === selected.grantId);
-  const selectedEstimate = selected.estimate ?? input.estimate;
-  if (!provider || !lane || !grant) {
-    return {
-      ok: false,
-      code: "no_eligible_lane",
-      reason: "The selected capacity lane could not be resolved.",
-      estimate: input.estimate,
-      candidates
-    };
-  }
-  const candidatePayload = candidates.map((candidate) => ({
-    providerId: candidate.providerId,
-    laneId: candidate.laneId,
-    grantId: candidate.grantId,
-    executionProviderId: candidate.executionProviderId ?? null,
-    executionProfileId: candidate.executionProfileId ?? null,
-    nativeUnit: candidate.nativeUnit ?? null,
-    remainingCredits: candidate.remainingCredits,
-    staticRemainingCredits: candidate.staticRemainingCredits ?? null,
-    derivedAvailableCredits: candidate.derivedAvailableCredits ?? null,
-    reservedNativeAmount: candidate.reservedNativeAmount ?? null,
-    derivedCapacityMode: candidate.derivedCapacityMode ?? "derived",
-    eligible: candidate.eligible,
-    reasons: candidate.reasons,
-    score: candidate.score.score,
-    reservedCredits: candidate.estimate?.reservedCredits ?? null,
-    qualityFit: candidate.qualityFit ?? null,
-    attentionEstimate: candidate.attentionEstimate ?? null,
-    utilityEstimate: candidate.utilityEstimate ?? null,
-    reservePrediction: candidate.reservePrediction ?? null,
-    trustScore: candidate.trustScore ?? null,
-    successProbability: candidate.successProbability ?? null,
-    pressure: candidate.pressure ?? null,
-    nativePressure: candidate.nativePressure ?? null,
-    derivedCapacity: candidate.derivedCapacity ?? null,
-    spilloverReason: candidate.spilloverReason ?? null
-  }));
-  const scorePayload = Object.fromEntries(candidates.map((candidate) => [routeCandidateKey(candidate), candidate.score]));
-  const reservation = {
-    capacityProviderId: provider.id,
-    laneId: lane.id,
-    teamId: input.plan.teamId,
-    projectId: input.plan.projectId,
-    workDayId: input.workDayId ?? null,
-    taskId: input.taskId ?? null,
-    state: "reserved",
-    reservedCredits: selectedEstimate.reservedCredits,
-    executionProviderId: selected.executionProviderId ?? null,
-    nativeUnit: selected.nativeUnit ?? null,
-    reservedNativeAmount: selected.reservedNativeAmount ?? null,
-    metadata: {
-      ...input.metadata ?? {},
-      grantId: grant.id,
-      derivedCapacityMode: selected.derivedCapacityMode ?? "derived",
-      executionProviderId: selected.executionProviderId ?? null,
-      nativeUnit: selected.nativeUnit ?? null,
-      reservedNativeAmount: selected.reservedNativeAmount ?? null,
-      derivedAvailableCredits: selected.derivedAvailableCredits ?? null,
-      nativePressure: selected.nativePressure ?? null,
-      executionProfileId: selected.executionProfileId ?? selectedEstimate.executionProfileId ?? null,
-      taskSignature: selectedEstimate.taskSignature,
-      estimatedCreditsP50: selectedEstimate.estimatedCreditsP50,
-      estimatedCreditsP90: selectedEstimate.estimatedCreditsP90,
-      routingScore: selected.score.score,
-      attentionEstimate: selected.attentionEstimate ?? null,
-      utilityEstimate: selected.utilityEstimate ?? null,
-      reservePrediction: selected.reservePrediction ?? null,
-      hybridExecutionPlan,
-      routingCandidates: candidatePayload
-    }
-  };
-  const routingDecision = {
-    taskId: input.taskId ?? null,
-    workDayId: input.workDayId ?? null,
-    projectId: input.plan.projectId,
-    selectedProviderId: provider.id,
-    selectedLaneId: lane.id,
-    selectedModel: input.selectedModel ?? selected.executionProfileId ?? null,
-    decision: "selected",
-    reason: selected.score.reasons.length > 0 ? selected.score.reasons.join(",") : "best_eligible_lane",
-    candidates: candidatePayload,
-    scores: scorePayload,
-    metadata: {
-      ...input.metadata ?? {},
-      grantId: grant.id,
-      executionProfileId: selected.executionProfileId ?? selectedEstimate.executionProfileId ?? null,
-      remainingCreditsBefore: selected.remainingCredits,
-      staticRemainingCreditsBefore: selected.staticRemainingCredits ?? null,
-      derivedCapacityMode: selected.derivedCapacityMode ?? "derived",
-      executionProviderId: selected.executionProviderId ?? null,
-      nativeUnit: selected.nativeUnit ?? null,
-      reservedNativeAmount: selected.reservedNativeAmount ?? null,
-      derivedAvailableCreditsBefore: selected.derivedAvailableCredits ?? null,
-      nativePressure: selected.nativePressure ?? null,
-      reservedCredits: selectedEstimate.reservedCredits,
-      attentionEstimate: selected.attentionEstimate ?? null,
-      utilityEstimate: selected.utilityEstimate ?? null,
-      reservePrediction: selected.reservePrediction ?? null,
-      hybridExecutionPlan,
-      escalationPath: candidatePayload.filter((candidate) => candidate.eligible).sort((left, right) => Number(left.reservedCredits ?? 0) - Number(right.reservedCredits ?? 0)).map((candidate) => candidate.executionProfileId).filter((value, index, array) => typeof value === "string" && value && array.indexOf(value) === index)
-    }
-  };
-  const ledgerEntry = {
-    capacityProviderId: provider.id,
-    laneId: lane.id,
-    teamId: input.plan.teamId,
-    projectId: input.plan.projectId,
-    workDayId: input.workDayId ?? null,
-    taskId: input.taskId ?? null,
-    phase: "reservation_created",
-    credits: selectedEstimate.reservedCredits,
-    source: input.source ?? "capacity_coordinator",
-    metadata: {
-      ...input.metadata ?? {},
-      grantId: grant.id,
-      executionProfileId: selected.executionProfileId ?? selectedEstimate.executionProfileId ?? null,
-      derivedCapacityMode: selected.derivedCapacityMode ?? "derived",
-      executionProviderId: selected.executionProviderId ?? null,
-      nativeUnit: selected.nativeUnit ?? null,
-      reservedNativeAmount: selected.reservedNativeAmount ?? null,
-      derivedAvailableCredits: selected.derivedAvailableCredits ?? null,
-      nativePressure: selected.nativePressure ?? null,
-      taskSignature: selectedEstimate.taskSignature,
-      attentionEstimate: selected.attentionEstimate ?? null,
-      utilityEstimate: selected.utilityEstimate ?? null,
-      reservePrediction: selected.reservePrediction ?? null,
-      hybridExecutionPlan
-    }
-  };
-  return {
-    ok: true,
-    provider,
-    lane,
-    grant,
-    estimate: selectedEstimate,
-    remainingCreditsBefore: selected.remainingCredits,
-    reservation,
-    routingDecision,
-    ledgerEntry,
-    capacityMetadata: {
-      providerId: provider.id,
-      laneId: lane.id,
-      grantId: grant.id,
-      reservationId: reservation.id ?? null,
-      routingDecisionId: routingDecision.id ?? null,
-      estimatedCreditsP50: selectedEstimate.estimatedCreditsP50,
-      estimatedCreditsP90: selectedEstimate.estimatedCreditsP90,
-      reservedCredits: selectedEstimate.reservedCredits,
-      executionProfileId: selected.executionProfileId ?? selectedEstimate.executionProfileId ?? null,
-      executionProviderId: selected.executionProviderId ?? null,
-      nativeUnit: selected.nativeUnit ?? null,
-      reservedNativeAmount: selected.reservedNativeAmount ?? null,
-      derivedAvailableCredits: selected.derivedAvailableCredits ?? null,
-      derivedCapacityMode: selected.derivedCapacityMode ?? "derived",
-      nativePressure: selected.nativePressure ?? null,
-      costMultiplier: selectedEstimate.costMultiplier ?? null,
-      score: selected.score.score,
-      attentionEstimate: selected.attentionEstimate ?? null,
-      utilityEstimate: selected.utilityEstimate ?? null,
-      reservePrediction: selected.reservePrediction ?? null,
-      hybridExecutionPlan,
-      candidates: candidatePayload
-    },
-    candidates
-  };
-}
-export {
-  ACTUAL_CREDIT_FORMULA_VERSION,
-  DEFAULT_EXECUTION_PROFILES,
-  DEFAULT_EXECUTION_PROFILE_ID,
-  DEFAULT_TASK_ADMISSION_POLICY,
-  buildCreditConversionProfileFromActuals,
-  buildTaskEstimateProfileFromActuals,
-  calculateActualCredits,
-  capacityRoutePressure,
-  computeWorkdayBudgetEnvelope,
-  createReservationReleaseEntry,
-  decideTaskAdmission,
-  deriveAvailableCredits,
-  estimateAttentionForTask,
-  estimateConfidenceFromProfile,
-  estimateForClassification,
-  estimateLearningPercentile,
-  estimateLearningVariance,
-  estimateProfileConfidenceScore,
-  estimateUtilityForTask,
-  isInterruptedUsageActual,
-  mutationRequiresRepositoryClaim,
-  nativeUsageAmount,
-  nativeUsageUnit,
-  normalizeAttentionPolicy,
-  normalizeExecutionProfile,
-  normalizeHybridExecutionPlan,
-  normalizePlanningPolicy,
-  normalizePredictiveReservePolicy,
-  normalizeTaskAdmissionPolicy,
-  normalizeTaskPlanProposal,
-  normalizeUtilityPolicy,
-  predictReserveForCapacityPlan,
-  progressivelyAdmitPlanProposal,
-  rankPlannedTaskNodes,
-  reservationHasCapacity,
-  reserveCreditsForEstimate,
-  routeAndReserveCapacity,
-  scoreCapacityLane,
-  selectBestCapacityLane,
-  selectCreditConversionProfile,
-  selectTaskEstimateProfile,
-  settleCapacityActuals,
-  shouldInterruptForCapacity,
-  summarizeCapacityPlan,
-  summarizeProjectCapacityPlan,
-  summarizeTeamCapacityPlan,
-  synthesizePlanEstimate,
-  validateTaskPlanProposal
-};