@treeseed/sdk 0.8.11 → 0.8.13

package/dist/capacity.js

@@ -1,6 +1,23 @@
+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 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;
@@ -19,6 +36,601 @@ function booleanValue(value) {
 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;
@@ -98,22 +710,125 @@ function lanePolicyReasons(lane, input) {
   return reasons;
 }
 function reserveCreditsForEstimate(input) {
-  const profileP50 = finiteNumber(input.profile?.creditsP50);
-  const profileP90 = finiteNumber(input.profile?.creditsP90);
+  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 confidence = input.confidence ?? "medium";
-  const reserved = confidence === "high" ? Math.max(p50, Math.ceil((p50 + p90) * 0.75)) : p90;
+  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
+    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) {
@@ -290,10 +1005,304 @@ function settleCapacityActuals(input) {
     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 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 score = input.baseScore.score + qualityBonus + laneModelFit + riskBonus + utilityBonus + cooperativeBonus - costPenalty - latency - congestion - quota - attention - context - 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 (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,
+    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;
@@ -301,31 +1310,135 @@ function routeAndReserveCapacity(input) {
       (lane2) => lane2.capacityProviderId === provider2.id && (!grant2.laneId || grant2.laneId === lane2.id)
     );
     for (const lane2 of lanes) {
-      const reasons = lanePolicyReasons(lane2, input);
       const remainingCredits = grantRemainingCredits(input.plan, grant2);
-      if (remainingCredits !== null && remainingCredits < input.estimate.reservedCredits && (grant2.overflowPolicy === "deny" || grant2.overflowPolicy === "hard_grant")) {
-        reasons.push("insufficient_budget");
+      const pressure = capacityRoutePressure(input.plan, provider2, lane2);
+      for (const profile of executionProfiles) {
+        const estimate = estimateForRouteProfile(input, profile);
+        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 = 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 (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
+        });
+        candidates.push({
+          providerId: provider2.id,
+          laneId: lane2.id,
+          grantId: grant2.id,
+          executionProfileId: profile.id,
+          remainingCredits,
+          score,
+          eligible: reasons.filter(
+            (reason) => reason !== "soft_budget_pressure" && reason !== "execution_profile_not_preferred"
+          ).length === 0,
+          reasons: [.../* @__PURE__ */ new Set([...reasons, ...score.reasons])],
+          estimate,
+          pressure,
+          qualityFit: score.qualityFit,
+          attentionEstimate,
+          utilityEstimate,
+          reservePrediction,
+          trustScore,
+          successProbability,
+          spilloverReason
+        });
       }
-      if (remainingCredits !== null && remainingCredits < input.estimate.reservedCredits && grant2.overflowPolicy === "approval_required") {
-        reasons.push("approval_required");
-      }
-      const score = scoreCapacityLane({
-        lane: lane2,
-        grant: grant2,
-        remainingCredits,
-        taskKind: input.taskKind ?? input.estimate.taskSignature,
-        requiredCapabilities: input.requiredCapabilities,
-        modelClass: input.modelClass ?? null
-      });
-      candidates.push({
-        providerId: provider2.id,
-        laneId: lane2.id,
-        grantId: grant2.id,
-        remainingCredits,
-        score,
-        eligible: reasons.length === 0,
-        reasons
-      });
     }
   }
   if (input.plan.providers.length === 0 || providers.length === 0) {
@@ -346,7 +1459,9 @@ function routeAndReserveCapacity(input) {
       candidates
     };
   }
-  const eligible = candidates.filter((candidate) => candidate.eligible).sort((left, right) => right.score.score - left.score.score || left.laneId.localeCompare(right.laneId));
+  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"));
@@ -362,6 +1477,7 @@ function routeAndReserveCapacity(input) {
   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,
@@ -375,12 +1491,22 @@ function routeAndReserveCapacity(input) {
     providerId: candidate.providerId,
     laneId: candidate.laneId,
     grantId: candidate.grantId,
+    executionProfileId: candidate.executionProfileId ?? null,
     remainingCredits: candidate.remainingCredits,
     eligible: candidate.eligible,
     reasons: candidate.reasons,
-    score: candidate.score.score
+    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,
+    spilloverReason: candidate.spilloverReason ?? null
   }));
-  const scorePayload = Object.fromEntries(candidates.map((candidate) => [candidate.laneId, candidate.score]));
+  const scorePayload = Object.fromEntries(candidates.map((candidate) => [routeCandidateKey(candidate), candidate.score]));
   const reservation = {
     capacityProviderId: provider.id,
     laneId: lane.id,
@@ -389,13 +1515,20 @@ function routeAndReserveCapacity(input) {
     workDayId: input.workDayId ?? null,
     taskId: input.taskId ?? null,
     state: "reserved",
-    reservedCredits: input.estimate.reservedCredits,
+    reservedCredits: selectedEstimate.reservedCredits,
     metadata: {
       ...input.metadata ?? {},
       grantId: grant.id,
-      taskSignature: input.estimate.taskSignature,
-      estimatedCreditsP50: input.estimate.estimatedCreditsP50,
-      estimatedCreditsP90: input.estimate.estimatedCreditsP90
+      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 = {
@@ -404,7 +1537,7 @@ function routeAndReserveCapacity(input) {
     projectId: input.plan.projectId,
     selectedProviderId: provider.id,
     selectedLaneId: lane.id,
-    selectedModel: input.selectedModel ?? null,
+    selectedModel: input.selectedModel ?? selected.executionProfileId ?? null,
     decision: "selected",
     reason: selected.score.reasons.length > 0 ? selected.score.reasons.join(",") : "best_eligible_lane",
     candidates: candidatePayload,
@@ -412,8 +1545,14 @@ function routeAndReserveCapacity(input) {
     metadata: {
       ...input.metadata ?? {},
       grantId: grant.id,
+      executionProfileId: selected.executionProfileId ?? selectedEstimate.executionProfileId ?? null,
       remainingCreditsBefore: selected.remainingCredits,
-      reservedCredits: input.estimate.reservedCredits
+      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 = {
@@ -424,12 +1563,17 @@ function routeAndReserveCapacity(input) {
     workDayId: input.workDayId ?? null,
     taskId: input.taskId ?? null,
     phase: "reservation_created",
-    credits: input.estimate.reservedCredits,
+    credits: selectedEstimate.reservedCredits,
     source: input.source ?? "capacity_coordinator",
     metadata: {
       ...input.metadata ?? {},
       grantId: grant.id,
-      taskSignature: input.estimate.taskSignature
+      executionProfileId: selected.executionProfileId ?? selectedEstimate.executionProfileId ?? null,
+      taskSignature: selectedEstimate.taskSignature,
+      attentionEstimate: selected.attentionEstimate ?? null,
+      utilityEstimate: selected.utilityEstimate ?? null,
+      reservePrediction: selected.reservePrediction ?? null,
+      hybridExecutionPlan
     }
   };
   return {
@@ -437,7 +1581,7 @@ function routeAndReserveCapacity(input) {
     provider,
     lane,
     grant,
-    estimate: input.estimate,
+    estimate: selectedEstimate,
     remainingCreditsBefore: selected.remainingCredits,
     reservation,
     routingDecision,
@@ -448,22 +1592,61 @@ function routeAndReserveCapacity(input) {
       grantId: grant.id,
       reservationId: reservation.id ?? null,
       routingDecisionId: routingDecision.id ?? null,
-      estimatedCreditsP50: input.estimate.estimatedCreditsP50,
-      estimatedCreditsP90: input.estimate.estimatedCreditsP90,
-      reservedCredits: input.estimate.reservedCredits
+      estimatedCreditsP50: selectedEstimate.estimatedCreditsP50,
+      estimatedCreditsP90: selectedEstimate.estimatedCreditsP90,
+      reservedCredits: selectedEstimate.reservedCredits,
+      executionProfileId: selected.executionProfileId ?? selectedEstimate.executionProfileId ?? 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 {
+  DEFAULT_EXECUTION_PROFILES,
+  DEFAULT_EXECUTION_PROFILE_ID,
+  DEFAULT_TASK_ADMISSION_POLICY,
+  buildTaskEstimateProfileFromActuals,
+  capacityRoutePressure,
+  computeWorkdayBudgetEnvelope,
   createReservationReleaseEntry,
+  decideTaskAdmission,
+  estimateAttentionForTask,
+  estimateConfidenceFromProfile,
+  estimateForClassification,
+  estimateLearningPercentile,
+  estimateLearningVariance,
+  estimateProfileConfidenceScore,
+  estimateUtilityForTask,
+  isInterruptedUsageActual,
+  mutationRequiresRepositoryClaim,
+  normalizeAttentionPolicy,
+  normalizeExecutionProfile,
+  normalizeHybridExecutionPlan,
+  normalizePlanningPolicy,
+  normalizePredictiveReservePolicy,
+  normalizeTaskAdmissionPolicy,
+  normalizeTaskPlanProposal,
+  normalizeUtilityPolicy,
+  predictReserveForCapacityPlan,
+  progressivelyAdmitPlanProposal,
+  rankPlannedTaskNodes,
   reservationHasCapacity,
   reserveCreditsForEstimate,
   routeAndReserveCapacity,
   scoreCapacityLane,
   selectBestCapacityLane,
+  selectTaskEstimateProfile,
   settleCapacityActuals,
+  shouldInterruptForCapacity,
   summarizeCapacityPlan,
   summarizeProjectCapacityPlan,
-  summarizeTeamCapacityPlan
+  summarizeTeamCapacityPlan,
+  synthesizePlanEstimate,
+  validateTaskPlanProposal
 };