@aiwg/cli 2026.9.19 → 2026.9.21

package/dist/src/decision/evaluate.js

@@ -1,18 +1,156 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import { canonicalJson } from '../security/artifact-trust.js';
 import { composeRuleset } from './compose.js';
+import { applyPrimitiveAcceptance, validatePrimitiveAcceptancePolicy } from './acceptance.js';
 import { DecisionPreDispatchError, decisionInvocationFingerprint, nextReceipt } from './receipts.js';
 import { admitEntry, EntryAdmissionError } from './entry.js';
+import { correlateAtomicBatch, decisionBatchQuestionId, planNativeDecisionBatches } from './batch.js';
+import { AdmissionError, AdmissionProfileError, decisionAdmissionRegistry } from './admission.js';
+import { runBoundedFair, SchedulerWaitError } from './scheduler.js';
+import { allocateEstimatedUsage, batchAccountingTotals, batchEnforcementCostMicros, deriveCost } from './batch-receipts/accounting.js';
+import { validOpaqueRequestId } from './batch-receipts/validate.js';
+import { batchResultReference, newBatchReceipt, nextBatchReceipt } from './batch-receipts/receipt.js';
+import { BatchRecordUnavailableError, BatchStoreIntegrityError, BatchStoreMigrationRequiredError } from './batch-receipts/protection.js';
+import { prepareAdapterRequest } from './compile-cache/runtime.js';
+import { providerPrefixEvidence } from './compile-cache/prefix.js';
+import { digestCachedResult, RESULT_CACHE_KEY_VERSION } from './result-cache/index.js';
+import { DecisionProjectionError, normalizeProjectionOrigin, projectDecisionState, } from './projection.js';
+import { DecisionRuntimeTrace, runtimeTraceOf } from './telemetry/runtime.js';
+import { assertContextQualified } from './context-qualification.js';
+import { assertContextPlanCurrent, ContextPlanError, planDecisionContext, recordContextActualUsage, } from './context-plan.js';
 import { DECISION_API_VERSION, DECISION_API_VERSION_STRUCTURED } from './types.js';
-import { artifactPin, assertArtifactPin, DecisionValidationError, resolveJsonPointer, validateAgainstSchema, validateBinding, validateDecisionValue, validateDefinition, validateDistribution, validateRuleset, } from './validate.js';
+import { artifactPin, assertArtifactPin, assertDecisionResultWriterVersion, DecisionValidationError, resolveJsonPointer, validateAgainstSchema, validateBinding, validateDecisionValue, validateDefinition, validateDistribution, validateRuleset, } from './validate.js';
 const RETRIABLE = new Set([
     'timeout', 'network-transient', 'rate-limited', 'overloaded', 'service-error',
 ]);
 export async function evaluateDecisionRuleset(request) {
+    // Telemetry hooks below record live spans through runtimeTraceOf(request); none can change the result.
+    const { request: traced, trace } = DecisionRuntimeTrace.begin(request);
+    const result = traced.resultCache?.policy.enabled
+        ? await evaluateWithResultCache(traced) : await evaluateDecisionRulesetInternal(traced);
+    await trace?.finish(result);
+    return result;
+}
+/** A cache hit is a historical result accompanied by a NEW caller receipt, not a fresh adapter attempt. */
+async function evaluateWithResultCache(request) {
+    const config = request.resultCache;
+    if (!config.policy.sideEffectFree || !request.receiptStore || !request.calibrationPin || !request.policyPin
+        || !config.recordCallerReceipt) {
+        throw new Error('Result cache requires side-effect-free policy, durable receipts, policy and calibration pins');
+    }
+    // Exact invocation replay wins over semantic reuse, including fingerprint mismatch protection.
+    const projectId = request.receiptProjectId ?? 'default';
+    if (projectId !== config.actor.projectId)
+        throw new Error('Cache actor and receipt project must match');
+    if (await request.receiptStore.read(request.invocationId, projectId))
+        return evaluateDecisionRulesetInternal(request);
+    // The experimental integration is deliberately narrower than the cache service: no
+    // batching, fallback, retries or context-dependent scheduling that can vary per caller.
+    if (request.ruleset.spec.evaluations.length !== 1 || request.batching?.enabled || request.context || request.scheduler?.enabled) {
+        throw new Error('Result cache supports only a single unbatched, unscheduled evaluation');
+    }
+    const snapshot = { ...request, ruleset: structuredClone(request.ruleset), binding: structuredClone(request.binding),
+        definitions: structuredClone(request.definitions), input: structuredClone(request.input) };
+    admitEntry(snapshot.input);
+    validateRuleset(snapshot.ruleset);
+    validateBinding(snapshot.binding, snapshot.ruleset);
+    validateAgainstSchema(snapshot.ruleset.spec.inputSchema, snapshot.input, 'ruleset input');
+    const [item] = resolveDefinitions(snapshot);
+    const targets = snapshot.binding.spec.evaluations[item.alias]?.targets;
+    if (!targets || targets.length !== 1 || targets[0].retry.maxRetries !== 0) {
+        throw new Error('Result cache requires one target without retry or fallback');
+    }
+    const target = targets[0];
+    const projected = await projectRuntimeInput(snapshot, item.alias, target, item.input, snapshot.adapters[target.adapter]);
+    // The key normalizes Unicode. The adapter must receive that same normalized
+    // representation or two byte-distinct prompts could alias to one cache entry.
+    assertNormalizedCacheInput(projected.input);
+    const identity = config.identityFor({ alias: item.alias, definition: structuredClone(item.definition),
+        target: structuredClone(target), projectedInput: structuredClone(projected.input) });
+    assertRuntimeCacheIdentity(identity, snapshot, item.pin, target, projected.input);
+    const alias = identity.modelCompatibility.mode === 'alias' ? identity.modelCompatibility : null;
+    if (alias && !config.verifyAliasSnapshot)
+        throw new Error('Alias cache requires a registry compatibility verifier');
+    const approved = alias ? await config.verifyAliasSnapshot(structuredClone(alias)) : true;
+    const outcome = await config.service.evaluate({ actor: config.actor,
+        policy: approved ? config.policy : { ...config.policy, enabled: false }, identity,
+        callerInvocationId: snapshot.invocationId, nowEpochMs: snapshot.now?.() }, async () => {
+        const original = await evaluateDecisionRulesetInternal(snapshot);
+        const attempt = original.spec.evaluations[item.alias]?.spec.attempts[0];
+        const receipt = await snapshot.receiptStore.read(snapshot.invocationId, projectId);
+        // Never publish an incomplete or uncertain receipt, even if an adapter returned a value.
+        const successful = original.spec.status === 'completed' && original.spec.evaluations[item.alias]?.spec.status === 'success'
+            && original.spec.evaluations[item.alias]?.spec.attempts.length === 1 && attempt?.actualModel
+            && attempt.remoteExecution !== 'unknown' && receipt?.state === 'completed';
+        return { result: original, resultDigest: digestCachedResult(original),
+            sourceInvocationId: snapshot.invocationId, sourceReceiptId: snapshot.invocationId,
+            evaluatedAtEpochMs: receipt?.completedAtEpochMs ?? snapshot.now?.() ?? Date.now(),
+            actualModel: attempt?.actualModel ?? '', uncertainty: (original.spec.evaluations[item.alias]?.spec.uncertainty ?? null),
+            calibrationStatus: original.spec.evaluations[item.alias]?.spec.calibrationCompatibility ? 'compatible' : 'pinned',
+            durationMs: attempt?.durationMs ?? 0, usage: attempt?.usage ?? { inputTokens: null, outputTokens: null, costUsd: null },
+            status: successful ? 'success' : 'terminal-failure', failureReason: successful ? 'none' : original.spec.reason };
+    });
+    if (outcome.receipt.disposition === 'cache-hit') {
+        const source = await snapshot.receiptStore.read(outcome.receipt.sourceInvocationId, projectId);
+        if (source?.state !== 'completed' || !source.result
+            || digestCachedResult(source.result) !== digestCachedResult(outcome.evidence.result)
+            || source.completedAtEpochMs !== outcome.receipt.originalEvaluatedAtEpochMs) {
+            throw new Error('Cached source receipt could not be verified');
+        }
+    }
+    const historical = structuredClone(outcome.evidence.result);
+    const released = { ...historical, spec: { ...historical.spec, cache: structuredClone(outcome.receipt) } };
+    // `spec.cache` is D15 evidence defined only by the v1alpha2 schema. A historical
+    // v1alpha1 entry cannot carry it, so it is refused before the caller receipt is persisted.
+    assertDecisionResultWriterVersion(released);
+    await config.recordCallerReceipt(structuredClone(outcome.receipt));
+    return released;
+}
+function assertNormalizedCacheInput(value) {
+    if (typeof value === 'string' && value !== value.normalize('NFC'))
+        throw new Error('Cache input must be NFC-normalized before dispatch');
+    if (Array.isArray(value))
+        value.forEach(assertNormalizedCacheInput);
+    else if (value !== null && typeof value === 'object') {
+        for (const [key, entry] of Object.entries(value)) {
+            if (key !== key.normalize('NFC'))
+                throw new Error('Cache input keys must be NFC-normalized before dispatch');
+            assertNormalizedCacheInput(entry);
+        }
+    }
+}
+function assertRuntimeCacheIdentity(identity, request, definition, target, projected) {
+    const sha = (value) => typeof value === 'string' && /^sha256:[a-f0-9]{64}$/.test(value);
+    const pinMatches = (left, right) => digestCachedResult(left) === digestCachedResult(right);
+    if (identity.keyVersion !== RESULT_CACHE_KEY_VERSION || !pinMatches(identity.definition, definition)
+        || !pinMatches(identity.ruleset, artifactPin(request.ruleset))
+        || !pinMatches(identity.binding, artifactPin(request.binding))
+        || identity.adapter.id !== target.adapter || identity.adapter.version !== target.adapterVersion
+        || identity.requestedModel !== target.model || identity.primitive !== Object.values(request.definitions).find(value => value.metadata.id === definition.id)?.spec.answer.kind
+        || identity.acceptancePolicyDigest !== digestCachedResult(target.acceptance)
+        || identity.calibrationDigest !== request.calibrationPin?.digest
+        || identity.runtimePolicyDigest !== request.policyPin?.digest
+        || digestCachedResult(identity.projectedInput) !== digestCachedResult(projected)
+        || ![identity.promptDigest, identity.subjectIdentityDigest, identity.projectionPolicyDigest,
+            identity.egressPolicyDigest].every(sha)
+        || !identity.backend || !identity.capabilityMode
+        || (identity.modelCompatibility.mode === 'pinned' && identity.modelCompatibility.actualModel !== target.model)
+        || (identity.modelCompatibility.mode === 'alias' && identity.modelCompatibility.alias !== target.model)) {
+        throw new Error('Invalid semantic result-cache identity');
+    }
+}
+async function evaluateDecisionRulesetInternal(request) {
+    const result = await evaluateDecisionRulesetUngated(request);
+    assertDecisionResultWriterVersion(result);
+    return result;
+}
+async function evaluateDecisionRulesetUngated(request) {
     let rulesetPin;
     let bindingPin;
-    let base;
+    let base = invalidResultBase(request);
     let resolved;
     let admissionStage = 'artifact';
+    let contextPlan;
     try {
         admitEntry(request.ruleset);
         admitEntry(request.binding);
@@ -20,6 +158,7 @@ export async function evaluateDecisionRuleset(request) {
         admissionStage = 'input';
         admitEntry(request.input);
         admissionStage = 'artifact';
+        validateEgressBoundaryConfiguration(request);
         validateRuleset(request.ruleset);
         rulesetPin = artifactPin(request.ruleset);
         bindingPin = artifactPin(request.binding);
@@ -31,16 +170,41 @@ export async function evaluateDecisionRuleset(request) {
         };
         base = resultBase(request, rulesetPin, bindingPin);
         validateBinding(request.binding, request.ruleset);
+        validateSchedulerPolicy(request);
         validateAgainstSchema(request.ruleset.spec.inputSchema, request.input, 'ruleset input');
         resolved = resolveDefinitions(request);
+        contextPlan = prepareContextPlan(request, resolved);
+        for (const item of resolved) {
+            for (const target of request.binding.spec.evaluations[item.alias].targets) {
+                if (target.acceptance.mode === 'primitive-policy') {
+                    if (request.binding.apiVersion !== DECISION_API_VERSION_STRUCTURED) {
+                        throw new DecisionValidationError('primitive-aware acceptance requires decision.aiwg.io/v1alpha2');
+                    }
+                    validatePrimitiveAcceptancePolicy(target.acceptance, item.definition);
+                }
+            }
+        }
     }
     catch (error) {
         const reason = error instanceof EntryAdmissionError && admissionStage === 'input'
             ? 'invalid-input' : classifyValidationFailure(error);
-        return failureResult(base ?? invalidResultBase(request), reason);
+        const failed = failureResult(base, reason);
+        return error instanceof ContextPlanError && request.context
+            ? { ...failed, spec: { ...failed.spec, contextFailure: contextFailureEvidence(error) } } : failed;
+    }
+    if (contextPlan)
+        base = withRulesetContext(base, contextPlan, []);
+    runtimeTraceOf(request)?.validated(false);
+    const batchPolicy = request.batchReceipts;
+    if (batchPolicy?.unknownCostBound && (!Number.isSafeInteger(batchPolicy.unknownCostBound.upperBoundMicros)
+        || batchPolicy.unknownCostBound.upperBoundMicros < 0 || !batchPolicy.unknownCostBound.policyId
+        || !batchPolicy.unknownCostBound.policyVersion))
+        return failureResult(base, 'invalid-definition');
+    if (batchPolicy?.maxCostMicros !== undefined && (!Number.isSafeInteger(batchPolicy.maxCostMicros)
+        || batchPolicy.maxCostMicros < 0 || !batchPolicy.unknownCostBound
+        || batchPolicy.unknownCostBound.upperBoundMicros > batchPolicy.maxCostMicros)) {
+        return failureResult(base, 'budget-exhausted');
     }
-    if (!base)
-        return failureResult(invalidResultBase(request), 'invalid-definition');
     const fingerprint = decisionInvocationFingerprint({
         invocationId: request.invocationId,
         value: request.input,
@@ -55,8 +219,10 @@ export async function evaluateDecisionRuleset(request) {
     const projectId = request.receiptProjectId ?? 'default';
     if (request.receiptStore) {
         try {
-            const acquisition = await request.receiptStore.acquire(request.invocationId, projectId, fingerprint);
+            const traceParent = runtimeTraceOf(request)?.traceParent;
+            const acquisition = await request.receiptStore.acquire(request.invocationId, projectId, fingerprint, traceParent ? { traceParent } : {});
             if (!acquisition.owner) {
+                runtimeTraceOf(request)?.linkOrigin(acquisition.receipt.traceParent, 'continuation', {});
                 if (acquisition.receipt.fingerprint !== fingerprint)
                     return failureResult(base, 'replay-mismatch');
                 if (acquisition.receipt.state === 'completed')
@@ -120,7 +286,9 @@ export async function evaluateDecisionRuleset(request) {
     const totalTimeout = AbortSignal.timeout(request.binding.spec.totalTimeoutMs);
     const totalAbort = AbortSignal.any([request.signal ?? new AbortController().signal, totalTimeout]);
     const evaluations = structuredClone(receipt?.evaluations ?? {});
+    const contextUsage = contextUsageFromEvaluations(evaluations);
     let attemptsUsed = Object.values(evaluations).reduce((sum, result) => sum + result.spec.attempts.length, 0);
+    const attemptBudget = new AttemptBudget(request.binding.spec.maxAttempts, attemptsUsed);
     try {
         if (reconciled && receipt?.pending) {
             const pending = receipt.pending;
@@ -129,8 +297,11 @@ export async function evaluateDecisionRuleset(request) {
             if (!item || !target)
                 throw new RemoteUncertainError();
             let observation;
+            let calibrationCompatibility;
             try {
-                observation = normalizeObservation(item.definition, target, reconciled);
+                const calibrated = normalizeObservationForRuntime({ request, item, target, observation: reconciled, now });
+                observation = calibrated.observation;
+                calibrationCompatibility = calibrated.calibrationCompatibility;
             }
             catch {
                 throw new RemoteUncertainError();
@@ -138,46 +309,345 @@ export async function evaluateDecisionRuleset(request) {
             if (observation.status !== 'success')
                 throw new RemoteUncertainError();
             const context = { request, item, rulesetPin, bindingPin, totalDeadline, signal: totalAbort, totalTimeout,
-                attemptsAvailable: request.binding.spec.maxAttempts, now, advance };
+                attemptBudget, now, advance };
             const attempts = [...pending.attempts, toAttempt(target, pending.ordinal, observation, 0)];
-            evaluations[item.alias] = decisionResult(context, observation, attempts);
+            evaluations[item.alias] = decisionResult(context, observation, attempts, calibrationCompatibility);
             attemptsUsed += attempts.length;
+            attemptBudget.consume(attempts.length);
             await advance('observation-received', { evaluations, pending: null });
         }
-        for (const item of resolved) {
-            if (evaluations[item.alias])
-                continue;
-            if (totalAbort.aborted) {
-                const reason = request.signal?.aborted ? 'cancelled' : 'timeout';
-                evaluations[item.alias] = emptyDecisionResult(request, item, rulesetPin, bindingPin, reason === 'cancelled' ? 'cancelled' : 'error', reason);
-                continue;
+        // Native batching may coexist with the invocation receipt only when a batch
+        // receipt owns the shared dispatch and its accounting before transport begins.
+        if ((!request.receiptStore || request.batchReceipts) && request.batching?.enabled) {
+            let batchCostSpent = 0;
+            // A terminal receipt must never point at values that cannot be recovered on replay.
+            if (request.batchReceipts && !request.batchReceipts.resultStore)
+                throw new ReceiptPersistenceError();
+            const candidates = [];
+            for (const item of resolved) {
+                if (evaluations[item.alias])
+                    continue;
+                const configured = request.binding.spec.evaluations[item.alias];
+                const target = configured?.targets.length && configured.targets.length <= 2
+                    && (configured.targets.length === 1 || request.batchReceipts)
+                    && (!configured.targets[1] || configured.targets[1].adapter === configured.targets[0]?.adapter
+                        && configured.targets[1].adapterVersion === configured.targets[0]?.adapterVersion)
+                    ? configured.targets[0] : undefined;
+                const adapter = target ? request.adapters[target.adapter] : undefined;
+                if (!target || !adapter)
+                    continue;
+                const capabilityFailure = await checkCapabilities(adapter, target, item.definition);
+                if (capabilityFailure || configured.targets[1] && await checkCapabilities(adapter, configured.targets[1], item.definition))
+                    continue;
+                candidates.push({ alias: item.alias, definition: item.definition, input: item.input, target, adapter,
+                    capabilities: await adapter.capabilities() });
             }
-            const execution = await evaluateOne({
-                request,
-                item,
-                rulesetPin,
-                bindingPin,
-                totalDeadline,
-                signal: totalAbort,
-                totalTimeout,
-                attemptsAvailable: request.binding.spec.maxAttempts - attemptsUsed,
-                now,
-                advance,
+            for (const plan of request.context?.rollout?.mode === 'observe-only' ? []
+                : contextPartitionedBatchPlans(planNativeDecisionBatches(candidates, request.batching), contextPlan)) {
+                if (plan.candidates.some(candidate => evaluations[candidate.alias]))
+                    continue;
+                const fallbackTargets = plan.candidates.map(candidate => request.binding.spec.evaluations[candidate.alias].targets[1]);
+                if (fallbackTargets.some(Boolean) && (fallbackTargets.some(target => !target)
+                    || fallbackTargets.some(target => canonicalJson(batchTargetIdentity(target))
+                        !== canonicalJson(batchTargetIdentity(fallbackTargets[0])))))
+                    continue;
+                const fallbackTarget = fallbackTargets[0];
+                if (attemptsUsed + plan.candidates.length > request.binding.spec.maxAttempts)
+                    continue;
+                if (request.batchReceipts?.maxCostMicros !== undefined && batchCostSpent
+                    + request.batchReceipts.unknownCostBound.upperBoundMicros > request.batchReceipts.maxCostMicros) {
+                    for (const candidate of plan.candidates) {
+                        const item = resolved.find(value => value.alias === candidate.alias);
+                        evaluations[item.alias] = decisionResult({ request, item, rulesetPin, bindingPin, totalDeadline, signal: totalAbort,
+                            totalTimeout, attemptBudget, now, advance, contextPlan, contextUsage }, observationFailure('budget-exhausted'), []);
+                    }
+                    continue;
+                }
+                const started = now();
+                const deadline = Math.min(totalDeadline, ...plan.candidates.map(candidate => started + candidate.target.timeoutMs));
+                const questionIds = plan.candidates.map(candidate => decisionBatchQuestionId(candidate.alias));
+                let observations = new Map();
+                let durableReceipt;
+                let batchReferences = new Map();
+                let dispatchCount = 0;
+                const batchSpans = [];
+                try {
+                    const adapter = plan.candidates[0].adapter;
+                    const projectedCandidates = await Promise.all(plan.candidates.map(async (candidate) => ({
+                        candidate,
+                        projected: await projectRuntimeInput(request, candidate.alias, candidate.target, candidate.input, adapter),
+                    })));
+                    // Both egress projections must be authorized before the first transport call.
+                    const fallbackProjectedCandidates = fallbackTarget ? await Promise.all(plan.candidates.map(async (candidate) => ({
+                        candidate, projected: await projectRuntimeInput(request, candidate.alias, fallbackTarget, candidate.input, adapter),
+                    }))) : null;
+                    if (request.batchReceipts) {
+                        const partition = request.batchReceipts.contextPlan.partitions.find(candidate => sameStringSet(candidate.questionIds, questionIds));
+                        if (!partition)
+                            throw new ReceiptPersistenceError();
+                        const initial = newBatchReceipt({
+                            tenantId: request.batchReceipts.tenantId,
+                            projectId: request.batchReceipts.projectId,
+                            batchId: durableBatchId(request.invocationId, plan.groupId, partition.id),
+                            invocationId: request.invocationId,
+                            runId: request.runId,
+                            contextPlan: request.batchReceipts.contextPlan,
+                            partition,
+                            nativeBatchGroupId: plan.groupId,
+                            subjectHash: request.batchReceipts.subjectHash,
+                            executionEnvelope: plan.candidates[0].capabilities.batch.executionEnvelope,
+                            nowEpochMs: started,
+                            traceParent: runtimeTraceOf(request)?.traceParent,
+                        });
+                        const acquired = await request.batchReceipts.store.acquire(initial);
+                        durableReceipt = acquired.receipt;
+                        if (!acquired.owner) {
+                            if (durableReceipt.status === 'completed') {
+                                const replayed = await request.batchReceipts.resultStore?.readMany(durableReceipt);
+                                if (!replayed || replayed.size !== questionIds.length)
+                                    throw new RemoteUncertainError();
+                                batchReferences = new Map(questionIds.map(questionId => [questionId, batchResultReference(durableReceipt, questionId)]));
+                                observations = replayed;
+                                // The shared request already has an owner. Never dispatch it again.
+                                throw new ReplayedBatchReceipt();
+                            }
+                            throw new RemoteUncertainError();
+                        }
+                        const running = nextBatchReceipt(durableReceipt, { status: 'running', updatedAtEpochMs: now() });
+                        if (!await request.batchReceipts.store.compareAndSwap(durableReceipt, running)) {
+                            throw new ReceiptPersistenceError();
+                        }
+                        durableReceipt = running;
+                    }
+                    let fallbackActive = false;
+                    for (let retry = 0; retry <= (request.batchReceipts
+                        ? plan.candidates[0].target.retry.maxRetries + (fallbackTarget ? fallbackTarget.retry.maxRetries + 1 : 0) : 0); retry++) {
+                        dispatchCount++;
+                        const activeTarget = fallbackActive ? fallbackTarget : plan.candidates[0].target;
+                        const preparedRequests = await Promise.all((fallbackActive ? fallbackProjectedCandidates : projectedCandidates)
+                            .map(({ candidate, projected }, index) => prepareAdapterRequest({
+                            alias: candidate.alias, questionId: questionIds[index], definition: structuredClone(candidate.definition),
+                            input: structuredClone(projected.input), target: structuredClone(activeTarget),
+                            invocationId: `${request.invocationId}:${plan.groupId}`, deadlineEpochMs: deadline,
+                            signal: totalAbort, callerSignal: request.signal ?? new AbortController().signal, totalSignal: totalAbort,
+                            resolveCredential: request.resolveCredential ?? unauthorizedCredential,
+                            ...(projected.evidence ? { projectionEvidence: projected.evidence } : {}),
+                        }, adapter, request.compileCache)));
+                        const dispatchedAt = now();
+                        const batchSpan = runtimeTraceOf(request)?.startBatch(plan.candidates.map(candidate => candidate.alias), plan.groupId, durableReceipt ? durableReceipt.attempts.length + 1 : dispatchCount);
+                        if (batchSpan)
+                            batchSpans.push(batchSpan);
+                        const response = await adapter.evaluateMany({ decisionSubject: plan.decisionSubject,
+                            requests: preparedRequests, ...(batchSpan ? { traceContext: batchSpan.traceContext } : {}) });
+                        if (batchSpan)
+                            batchSpan.response = response;
+                        if (contextPlan && response.sharedUsage.inputTokens !== null) {
+                            recordRuntimeContextUsage(contextPlan, questionIds, response.sharedUsage.inputTokens, contextUsage);
+                        }
+                        observations = correlateAtomicBatch(questionIds, response.answers.map(answer => ({ questionId: answer.questionId, value: answer.observation })));
+                        // Validate every sibling before publishing any result: the batch is atomic.
+                        const normalized = new Map();
+                        plan.candidates.forEach((candidate, index) => {
+                            const item = resolved.find(value => value.alias === candidate.alias);
+                            // Siblings share transport identity, not acceptance: each answer is judged by its own target's policy.
+                            const ownTarget = fallbackActive ? request.binding.spec.evaluations[candidate.alias].targets[1] : candidate.target;
+                            normalized.set(questionIds[index], normalizeObservationForRuntime({ request, item, target: ownTarget,
+                                observation: observations.get(questionIds[index]), now }));
+                        });
+                        observations = new Map([...normalized].map(([id, value]) => [id, value.observation]));
+                        if (durableReceipt && request.batchReceipts) {
+                            const requestIds = uniqueNonNull(response.answers.map(answer => answer.observation.requestId));
+                            if (requestIds.length > 1)
+                                throw new Error('batch response contained multiple provider request IDs');
+                            const models = uniqueNonNull(response.answers.map(answer => answer.observation.actualModel));
+                            const derivedCost = request.batchReceipts.priceCatalog
+                                ? deriveCost(response.sharedUsage, request.batchReceipts.priceCatalog) : { kind: 'unknown' };
+                            const cost = providerCost(response.sharedUsage.costUsd)
+                                ?? (derivedCost.kind !== 'unknown' ? derivedCost : request.batchReceipts.unknownCostBound
+                                    ? { kind: 'bounded-unknown', currency: 'USD',
+                                        upperBoundMicros: request.batchReceipts.unknownCostBound.upperBoundMicros,
+                                        boundPolicyId: request.batchReceipts.unknownCostBound.policyId,
+                                        boundPolicyVersion: request.batchReceipts.unknownCostBound.policyVersion }
+                                    : { kind: 'unknown' });
+                            const certainties = response.answers.map(answer => answer.observation.dispatchCertainty);
+                            const attemptStatus = certainties.some(value => value === 'unknown')
+                                ? 'execution-uncertain' : certainties.every(value => value === 'not-sent') ? 'not-sent'
+                                : [...observations.values()].every(value => value.status === 'success') ? 'succeeded' : 'failed';
+                            const attempt = {
+                                ordinal: durableReceipt.attempts.length + 1,
+                                adapterId: adapter.id,
+                                adapterVersion: adapter.version,
+                                requestedModel: activeTarget.model,
+                                actualModel: models.length === 1 ? models[0] : null,
+                                providerRequestId: requestIds[0] && validOpaqueRequestId(requestIds[0]) ? requestIds[0] : null,
+                                status: attemptStatus,
+                                dispatchedAtEpochMs: attemptStatus === 'not-sent' ? null : dispatchedAt,
+                                completedAtEpochMs: now(),
+                                usage: { inputTokens: response.sharedUsage.inputTokens, outputTokens: response.sharedUsage.outputTokens },
+                                cost,
+                                fallbackFromAttemptOrdinal: fallbackActive ? durableReceipt.attempts.at(-1)?.ordinal ?? null : null,
+                            };
+                            const answerReferences = plan.candidates.map((candidate, index) => ({
+                                questionId: questionIds[index],
+                                answerId: durableAnswerId(durableReceipt.batchId, questionIds[index]),
+                                resultId: `${request.invocationId}-${candidate.alias}`,
+                            }));
+                            const retriable = attemptStatus === 'failed'
+                                && [...observations.values()].every(value => RETRIABLE.has(value.reason));
+                            const canRetry = retriable && (fallbackActive
+                                ? retry - plan.candidates[0].target.retry.maxRetries - 1 < fallbackTarget.retry.maxRetries
+                                : retry < plan.candidates[0].target.retry.maxRetries)
+                                && attemptsUsed + (dispatchCount + 1) * plan.candidates.length <= request.binding.spec.maxAttempts
+                                && (request.batchReceipts.maxCostMicros === undefined
+                                    || (batchEnforcementCostMicros({ ...durableReceipt, attempts: [...durableReceipt.attempts, attempt] }) ?? Infinity)
+                                        + request.batchReceipts.unknownCostBound.upperBoundMicros <= request.batchReceipts.maxCostMicros)
+                                && now() < deadline;
+                            const canFallback = attemptStatus === 'failed' && !canRetry && !fallbackActive && !!fallbackTarget
+                                && [...observations.values()].every(value => plan.candidates.every(candidate => request.binding.spec.evaluations[candidate.alias].fallbackOn.includes(value.reason)))
+                                && attemptsUsed + (dispatchCount + 1) * plan.candidates.length <= request.binding.spec.maxAttempts
+                                && (request.batchReceipts.maxCostMicros === undefined
+                                    || (batchEnforcementCostMicros({ ...durableReceipt, attempts: [...durableReceipt.attempts, attempt] }) ?? Infinity)
+                                        + request.batchReceipts.unknownCostBound.upperBoundMicros <= request.batchReceipts.maxCostMicros)
+                                && now() < deadline;
+                            if (canRetry || canFallback) {
+                                const pending = nextBatchReceipt(durableReceipt, { status: 'running', updatedAtEpochMs: now(),
+                                    attempts: [...durableReceipt.attempts, attempt] });
+                                if (!await request.batchReceipts.store.compareAndSwap(durableReceipt, pending))
+                                    throw new ReceiptPersistenceError();
+                                durableReceipt = pending;
+                                if (canFallback)
+                                    fallbackActive = true;
+                                continue;
+                            }
+                            const terminalStatus = attemptStatus === 'succeeded' ? 'completed'
+                                : attemptStatus === 'execution-uncertain' ? 'execution-uncertain' : 'failed';
+                            const terminal = nextBatchReceipt(durableReceipt, { status: terminalStatus, updatedAtEpochMs: now(),
+                                attempts: [...durableReceipt.attempts, attempt],
+                                ...(terminalStatus === 'completed' ? { answerReferences,
+                                    allocations: allocateEstimatedUsage(questionIds, batchAccountingTotals({ ...durableReceipt,
+                                        attempts: [...durableReceipt.attempts, attempt] }).usage) } : {}) });
+                            if (terminalStatus === 'completed') {
+                                // Publish values before committing the terminal receipt: a crash between these
+                                // writes leaves an uncertain receipt, never a successful but unreadable replay.
+                                observations = resultOnlyBatchObservations(observations);
+                                await request.batchReceipts.resultStore.writeMany(terminal, observations);
+                            }
+                            if (!await request.batchReceipts.store.compareAndSwap(durableReceipt, terminal)) {
+                                throw new ReceiptPersistenceError();
+                            }
+                            durableReceipt = terminal;
+                            if (terminalStatus === 'completed') {
+                                batchReferences = new Map(questionIds.map(questionId => [questionId, batchResultReference(terminal, questionId)]));
+                            }
+                            else
+                                observations = resultOnlyBatchObservations(new Map(questionIds.map(questionId => [questionId, observationFailure(terminalStatus === 'execution-uncertain' ? 'execution-uncertain' : 'service-error')])));
+                        }
+                        break;
+                    }
+                }
+                catch (error) {
+                    if (error instanceof ReplayedBatchReceipt || error.name === 'ReplayedBatchReceipt') {
+                        // References and reconstructed result observations were prepared above.
+                    }
+                    else if (durableReceipt && request.batchReceipts && durableReceipt.status === 'running') {
+                        const uncertain = nextBatchReceipt(durableReceipt, { status: 'execution-uncertain', updatedAtEpochMs: now(),
+                            attempts: [...durableReceipt.attempts, uncertainBatchAttempt(plan, started, now())] });
+                        if (!await request.batchReceipts.store.compareAndSwap(durableReceipt, uncertain)) {
+                            throw new ReceiptPersistenceError();
+                        }
+                        observations = new Map(questionIds.map(id => [id, observationFailure('execution-uncertain')]));
+                    }
+                    else if (error instanceof BatchRecordUnavailableError || error instanceof BatchStoreIntegrityError
+                        || error instanceof BatchStoreMigrationRequiredError) {
+                        // Erased, expired, tampered or unmigrated durable state is never re-dispatched and never
+                        // falls back to another read of stored values. Only lifecycle unavailability gets the
+                        // dedicated reason; integrity and migration failures stay persistence-error.
+                        const reason = error instanceof BatchRecordUnavailableError ? 'batch-record-unavailable' : 'persistence-error';
+                        observations = new Map(questionIds.map(id => [id, observationFailure(reason)]));
+                    }
+                    else if (error instanceof ReceiptPersistenceError || error instanceof RemoteUncertainError) {
+                        throw error;
+                    }
+                    else {
+                        const replayed = durableReceipt?.status === 'completed'
+                            ? await request.batchReceipts?.resultStore?.readMany(durableReceipt) : undefined;
+                        if (replayed && replayed.size === questionIds.length) {
+                            batchReferences = new Map(questionIds.map(questionId => [questionId, batchResultReference(durableReceipt, questionId)]));
+                            observations = replayed;
+                        }
+                        else {
+                            observations = new Map(questionIds.map(id => [id, observationFailure(error instanceof DecisionProjectionError ? 'data-boundary-denied' : 'invalid-output')]));
+                        }
+                    }
+                }
+                runtimeTraceOf(request)?.finishBatch(batchSpans, durableReceipt);
+                plan.candidates.forEach((candidate, index) => {
+                    const item = resolved.find(value => value.alias === candidate.alias);
+                    const evidence = { mode: 'native', groupId: plan.groupId, questionId: questionIds[index] };
+                    const observation = observations.get(questionIds[index]);
+                    const context = { request, item, rulesetPin, bindingPin, totalDeadline, signal: totalAbort, totalTimeout,
+                        attemptBudget, now, advance, batchResult: batchReferences.get(questionIds[index]), contextPlan, contextUsage };
+                    const calibrationCompatibility = request.calibrationCompatibility && observation.status === 'success'
+                        ? normalizeObservationForRuntime({ request, item, target: durableReceipt?.attempts.at(-1)?.fallbackFromAttemptOrdinal
+                                ? fallbackTarget : candidate.target, observation, now }).calibrationCompatibility
+                        : undefined;
+                    const historical = durableReceipt?.attempts.map(attempt => {
+                        const failure = observationFailure(attempt.status === 'execution-uncertain'
+                            ? 'execution-uncertain' : 'service-error');
+                        const value = attempt.status === 'succeeded' ? observation : resultOnlyBatchObservations(new Map([[questionIds[index], failure]])).get(questionIds[index]);
+                        return toAttempt({ ...candidate.target, model: attempt.requestedModel }, attempt.ordinal, value, Math.max(0, (attempt.completedAtEpochMs ?? durableReceipt.updatedAtEpochMs)
+                            - (attempt.dispatchedAtEpochMs ?? durableReceipt.createdAtEpochMs)), evidence);
+                    });
+                    evaluations[item.alias] = decisionResult(context, observation, historical?.length ? historical : [toAttempt(candidate.target, 1, observation, Math.max(0, now() - started), evidence)], calibrationCompatibility);
+                });
+                if (durableReceipt?.status === 'completed' || durableReceipt?.status === 'failed') {
+                    batchCostSpent += batchEnforcementCostMicros(durableReceipt) ?? Infinity;
+                }
+                attemptsUsed += Math.max(1, dispatchCount) * plan.candidates.length;
+                attemptBudget.consume(Math.max(1, dispatchCount) * plan.candidates.length);
+            }
+        }
+        const concurrency = effectiveConcurrency(request);
+        const remainingItems = resolved.filter(item => !evaluations[item.alias]);
+        const waves = contextPlan
+            ? [...new Set(contextPlan.partitions.map(partition => partition.wave))].sort((left, right) => left - right)
+                .map(wave => remainingItems.filter(item => contextPlan.partitions.some(partition => partition.wave === wave && partition.questionIds.includes(decisionBatchQuestionId(item.alias)))))
+            : [remainingItems];
+        for (const waveItems of waves) {
+            const scheduled = await runBoundedFair(waveItems.map(item => ({ value: item, lane: schedulerLane(request, item) })), concurrency, async (item, _index, slot) => evaluateOne({ request, item, rulesetPin, bindingPin, totalDeadline, signal: totalAbort, totalTimeout,
+                attemptBudget, now, advance, batchEvidence: singleBatchEvidence(request, item.alias), contextPlan, contextUsage,
+                // Receipt v2 keeps a strictly serial chronology, so only receipt-free scheduled runs yield during backoff.
+                ...(request.scheduler?.enabled && !request.receiptStore ? { suspend: slot.suspend } : {}) }), { signal: totalAbort, deadlineEpochMs: totalDeadline, now });
+            scheduled.forEach((execution, index) => {
+                const item = waveItems[index];
+                if (execution instanceof SchedulerWaitError) {
+                    const reason = execution.reason === 'cancelled' ? 'cancelled' : 'timeout';
+                    evaluations[item.alias] = emptyDecisionResult(request, item, rulesetPin, bindingPin, reason === 'cancelled' ? 'cancelled' : 'error', reason);
+                }
+                else {
+                    evaluations[item.alias] = execution;
+                }
             });
-            attemptsUsed += execution.spec.attempts.length;
-            evaluations[item.alias] = execution;
-            await advance('observation-received', { evaluations, pending: null });
         }
-        if (receipt?.state === 'execution-uncertain')
+        // Receipt v2 has one pending slot; concurrency is forced to one when durable
+        // ownership is enabled, so this update remains an atomic chronology.
+        if (request.receiptStore)
+            await advance('observation-received', { evaluations, pending: null });
+        if (receipt?.state === 'execution-uncertain') {
+            releaseAdmissionBudget(request);
             return failureResult(base, 'execution-uncertain', evaluations);
+        }
+        const orderedEvaluations = Object.fromEntries(resolved
+            .filter(item => evaluations[item.alias])
+            .map(item => [item.alias, evaluations[item.alias]]));
         let result;
         if (totalAbort.aborted) {
             const reason = request.signal?.aborted ? 'cancelled' : 'timeout';
-            result = { ...base, spec: { ...base.spec, status: reason === 'cancelled' ? 'cancelled' : 'error', reason, matchedRules: [], evaluations } };
+            result = { ...base, spec: { ...base.spec, status: reason === 'cancelled' ? 'cancelled' : 'error', reason, matchedRules: [], evaluations: orderedEvaluations } };
         }
         else {
             try {
-                const composition = composeRuleset(request.ruleset, request.input, evaluations);
+                const composition = composeRuleset(request.ruleset, request.input, orderedEvaluations);
                 result = {
                     ...base,
                     spec: {
@@ -186,16 +656,25 @@ export async function evaluateDecisionRuleset(request) {
                         reason: composition.reason,
                         ...(composition.outcome !== undefined ? { outcome: composition.outcome } : {}),
                         matchedRules: composition.matchedRules,
-                        evaluations,
+                        evaluations: orderedEvaluations,
                     },
                 };
             }
             catch {
-                result = { ...base, spec: { ...base.spec, status: 'error', reason: 'invalid-output', matchedRules: [], evaluations } };
+                result = { ...base, spec: { ...base.spec, status: 'error', reason: 'invalid-output', matchedRules: [], evaluations: orderedEvaluations } };
             }
         }
+        // Either incomplete-context signal (context plan or projection evidence) prohibits automatic action.
+        if ((contextPlan && !contextPlan.automaticActionAllowed || projectionBlockedAutomaticAction.has(request))
+            && (result.spec.status === 'completed' || result.spec.status === 'defaulted')) {
+            const { outcome: _outcome, ...withoutOutcome } = result.spec;
+            result = { ...result, spec: { ...withoutOutcome, status: 'review', reason: 'insufficient-information' } };
+        }
         await advance('composed');
+        if (contextPlan)
+            result = withRulesetContext(result, contextPlan, contextUsage);
         await advance('completed', { result });
+        releaseAdmissionBudget(request);
         return result;
     }
     catch (error) {
@@ -206,8 +685,10 @@ export async function evaluateDecisionRuleset(request) {
             catch {
                 return failureResult(base, 'persistence-error', evaluations);
             }
+            releaseAdmissionBudget(request);
             return failureResult(base, 'execution-uncertain', evaluations);
         }
+        releaseAdmissionBudget(request);
         return failureResult(base, 'persistence-error', evaluations);
     }
 }
@@ -215,25 +696,35 @@ class ReceiptPersistenceError extends Error {
 }
 class RemoteUncertainError extends Error {
 }
+class ReplayedBatchReceipt extends Error {
+    constructor() { super('replayed batch receipt'); this.name = 'ReplayedBatchReceipt'; }
+}
 async function evaluateOne(context) {
     const evaluation = context.request.binding.spec.evaluations[context.item.alias];
     const attempts = [];
     let final = observationFailure('budget-exhausted');
+    let calibrationCompatibility;
+    const trace = runtimeTraceOf(context.request);
     for (let targetIndex = 0; targetIndex < evaluation.targets.length; targetIndex += 1) {
         const target = evaluation.targets[targetIndex];
         if (context.signal.aborted || context.now() >= context.totalDeadline) {
             final = interruption(context);
             break;
         }
-        if (attempts.length >= context.attemptsAvailable) {
+        if (!context.attemptBudget.available) {
             final = observationFailure('budget-exhausted');
             break;
         }
         const adapter = context.request.adapters[target.adapter];
         const capabilityFailure = await checkCapabilities(adapter, target, context.item.definition);
         if (capabilityFailure) {
+            if (!context.attemptBudget.claim()) {
+                final = observationFailure('budget-exhausted');
+                break;
+            }
             final = capabilityFailure;
-            attempts.push(toAttempt(target, attempts.length + 1, final, 0));
+            attempts.push(toAttempt(target, attempts.length + 1, final, 0, context.batchEvidence));
+            trace?.endAttempt(trace.startAttempt(context.item.alias, target, attempts.length, targetIndex > 0), attempts.at(-1));
         }
         else {
             for (let retry = 0; retry <= target.retry.maxRetries; retry += 1) {
@@ -241,16 +732,18 @@ async function evaluateOne(context) {
                     final = interruption(context);
                     break;
                 }
-                if (attempts.length >= context.attemptsAvailable) {
+                if (!context.attemptBudget.claim()) {
                     final = observationFailure('budget-exhausted');
                     break;
                 }
                 const started = context.now();
+                const span = trace?.startAttempt(context.item.alias, target, attempts.length + 1, targetIndex > 0);
                 const attemptDeadline = Math.min(context.totalDeadline, started + target.timeoutMs);
                 try {
+                    const projected = await projectRuntimeInput(context.request, context.item.alias, target, context.item.input, adapter, span);
                     await context.advance('dispatched', { pending: { alias: context.item.alias, targetIndex, ordinal: attempts.length + 1, attempts } });
                     try {
-                        final = await invokeWithDeadline(context, adapter, target, attemptDeadline, attempts.length + 1);
+                        final = await invokeWithDeadline(context, adapter, target, attemptDeadline, attempts.length + 1, projected, span?.traceContext);
                     }
                     catch (error) {
                         if (context.request.receiptStore && !(error instanceof DecisionPreDispatchError))
@@ -263,14 +756,22 @@ async function evaluateOne(context) {
                         throw new RemoteUncertainError();
                     }
                     await context.advance('observation-received');
-                    final = normalizeObservation(context.item.definition, target, final);
+                    const calibrated = normalizeObservationForRuntime({ request: context.request, item: context.item, target,
+                        observation: final, now: context.now });
+                    final = calibrated.observation;
+                    calibrationCompatibility = calibrated.calibrationCompatibility;
+                    if (context.contextPlan && final.usage.inputTokens !== null && context.contextUsage) {
+                        recordRuntimeContextUsage(context.contextPlan, decisionBatchQuestionId(context.item.alias), final.usage.inputTokens, context.contextUsage);
+                    }
                 }
                 catch (error) {
                     if (error instanceof ReceiptPersistenceError || error instanceof RemoteUncertainError)
                         throw error;
-                    final = observationFailure(error instanceof DecisionValidationError ? 'invalid-output' : 'service-error');
+                    final = observationFailure(error instanceof DecisionProjectionError ? 'data-boundary-denied'
+                        : error instanceof DecisionValidationError ? 'invalid-output' : 'service-error');
                 }
-                attempts.push(toAttempt(target, attempts.length + 1, final, Math.max(0, context.now() - started)));
+                attempts.push(toAttempt(target, attempts.length + 1, final, Math.max(0, context.now() - started), context.batchEvidence));
+                trace?.endAttempt(span, attempts.at(-1));
                 if (final.status === 'success')
                     break;
                 if (!RETRIABLE.has(final.reason) || retry === target.retry.maxRetries)
@@ -286,8 +787,10 @@ async function evaluateOne(context) {
                     break;
                 }
                 attempts[attempts.length - 1].retryDelayMs = delayMs;
+                trace?.retryScheduled(span, delayMs);
                 try {
-                    await (context.request.delay ?? abortableDelay)(delayMs, context.signal);
+                    const backoff = () => (context.request.delay ?? abortableDelay)(delayMs, context.signal);
+                    await (context.suspend ? context.suspend(backoff) : backoff());
                 }
                 catch {
                     final = interruption(context);
@@ -305,14 +808,16 @@ async function evaluateOne(context) {
         if (!hasNext || !evaluation.fallbackOn.includes(final.reason))
             break;
     }
-    return decisionResult(context, final, attempts);
+    return decisionResult(context, final, attempts, calibrationCompatibility);
 }
-async function invokeWithDeadline(context, adapter, target, deadlineEpochMs, ordinal) {
+async function invokeWithDeadline(context, adapter, target, deadlineEpochMs, ordinal, projected, traceContext) {
     const controller = new AbortController();
     const signal = AbortSignal.any([context.signal, controller.signal]);
     const timeoutMs = Math.max(1, deadlineEpochMs - context.now());
     let timer;
     let removeAbortListener = () => undefined;
+    let admissionEvidence;
+    let releaseAdmission;
     const boundary = new Promise(resolve => {
         timer = setTimeout(() => {
             controller.abort(new DOMException('Decision target timed out', 'TimeoutError'));
@@ -327,39 +832,186 @@ async function invokeWithDeadline(context, adapter, target, deadlineEpochMs, ord
         }
     });
     try {
-        const observed = await Promise.race([
-            adapter.evaluate({
-                alias: context.item.alias,
-                definition: structuredClone(context.item.definition),
-                input: structuredClone(context.item.input),
-                target: structuredClone(target),
-                invocationId: `${context.request.invocationId}:${context.item.alias}:${ordinal}`,
-                deadlineEpochMs,
-                signal,
-                callerSignal: context.request.signal ?? new AbortController().signal,
-                totalSignal: context.signal,
-                resolveCredential: context.request.resolveCredential ?? unauthorizedCredential,
-                onRemoteHandle: async (handle) => {
-                    try {
-                        const previous = await context.request.receiptStore?.read(context.request.invocationId, context.request.receiptProjectId ?? 'default');
-                        if (previous && !previous.remoteHandles.includes(handle))
-                            await context.advance('remote-handle-known', { remoteHandles: [...previous.remoteHandles, handle] });
-                    }
-                    catch {
-                        throw new ReceiptPersistenceError();
-                    }
-                },
-            }),
+        if (context.request.scheduler?.enabled) {
+            const policy = context.request.scheduler;
+            const controller = decisionAdmissionRegistry.controllerFor(policy, context.now);
+            const admissionStarted = context.now();
+            const trace = runtimeTraceOf(context.request);
+            try {
+                const lease = await controller.acquire({ budgetId: context.request.invocationId,
+                    principalId: policy.principal.id, workspaceId: policy.workspace.id,
+                    providerId: target.adapter, estimate: policy.estimate?.(context.item.alias, target, context.item.input) ?? { attempts: 1, batchSize: 1, items: 1 },
+                    deadlineEpochMs, signal });
+                admissionEvidence = lease.evidence;
+                const admitSpan = trace?.startAdmission(context.item.alias, target.adapter, admissionStarted, lease.evidence);
+                releaseAdmission = outcome => {
+                    lease.release(outcome);
+                    trace?.endAdmission(admitSpan, lease.evidence);
+                };
+                policy.onEvidence?.(context.item.alias, lease.evidence);
+            }
+            catch (error) {
+                if (error instanceof AdmissionError) {
+                    trace?.startAdmission(context.item.alias, target.adapter, admissionStarted, error.evidence);
+                    policy.onEvidence?.(context.item.alias, error.evidence);
+                    // Nothing was sent. A target timeout that aborts a queued wait is a timeout, not a caller cancellation.
+                    const failure = error.evidence.reason === 'cancelled' && !context.request.signal?.aborted
+                        ? interruption(context) : observationFailure(admissionReason(error));
+                    return { ...failure, dispatchCertainty: 'not-sent', admission: error.evidence };
+                }
+                throw error;
+            }
+        }
+        const preparedRequest = await prepareAdapterRequest({
+            alias: context.item.alias,
+            definition: structuredClone(context.item.definition),
+            input: structuredClone(projected.input),
+            target: structuredClone(target),
+            invocationId: `${context.request.invocationId}:${context.item.alias}:${ordinal}`,
+            deadlineEpochMs,
+            signal,
+            callerSignal: context.request.signal ?? new AbortController().signal,
+            totalSignal: context.signal,
+            resolveCredential: context.request.resolveCredential ?? unauthorizedCredential,
+            ...(projected.evidence ? { projectionEvidence: projected.evidence } : {}),
+            ...(traceContext ? { traceContext } : {}),
+            onRemoteHandle: async (handle) => {
+                try {
+                    const previous = await context.request.receiptStore?.read(context.request.invocationId, context.request.receiptProjectId ?? 'default');
+                    if (previous && !previous.remoteHandles.includes(handle))
+                        await context.advance('remote-handle-known', { remoteHandles: [...previous.remoteHandles, handle] });
+                }
+                catch {
+                    throw new ReceiptPersistenceError();
+                }
+            },
+        }, adapter, context.request.compileCache);
+        const observedWithTransportMetadata = await Promise.race([
+            adapter.evaluate(preparedRequest),
             boundary,
         ]);
-        return context.request.signal?.aborted ? observationFailure('cancelled', 'cancelled', observed, 'caller-cancelled') : observed;
+        const { providerPrefixReport, ...observedWithoutPrefixReport } = observedWithTransportMetadata;
+        let observed = observedWithoutPrefixReport;
+        if (context.request.providerPrefix) {
+            try {
+                const identity = context.request.providerPrefix.identityFor({
+                    request: preparedRequest,
+                    adapter,
+                    observation: observedWithTransportMetadata,
+                });
+                const evidence = providerPrefixEvidence(identity, providerPrefixReport ?? { kind: 'unreported' }, context.now());
+                observed = { ...observed, providerPrefix: evidence };
+                context.request.providerPrefix.onEvidence?.({ alias: context.item.alias, evidence });
+            }
+            catch {
+                // Provider cache metadata is observability-only and cannot alter decision semantics.
+            }
+        }
+        const result = context.request.signal?.aborted ? observationFailure('cancelled', 'cancelled', observed, 'caller-cancelled') : observed;
+        releaseAdmission?.({ success: result.status === 'success', ...(result.retryAfterMs === undefined ? {} : { retryAfterMs: result.retryAfterMs }) });
+        return admissionEvidence ? { ...result, admission: admissionEvidence } : result;
     }
     finally {
+        releaseAdmission?.({ success: false });
         if (timer)
             clearTimeout(timer);
         removeAbortListener();
     }
 }
+/** Requests whose projection evidence prohibited automatic action (allowed incomplete context). */
+const projectionBlockedAutomaticAction = new WeakSet();
+function isUnprojectedLocalOptOut(projection) {
+    return !!projection && projection.mode === 'unprojected-local';
+}
+/**
+ * The projection field is host code, never portable data: it must be either a
+ * resolver-backed policy or the exact opt-out object. Anything else (including a
+ * JSON-shaped policy lifted from input or definitions) is rejected before dispatch.
+ */
+function validateEgressBoundaryConfiguration(request) {
+    const projection = request.projection;
+    if (projection === undefined)
+        return;
+    if (!projection || typeof projection !== 'object' || Array.isArray(projection)) {
+        throw new DecisionValidationError('unsupported egress boundary configuration');
+    }
+    const record = projection;
+    if ('mode' in record) {
+        if (record.mode !== 'unprojected-local' || Object.keys(record).length !== 1) {
+            throw new DecisionValidationError('unsupported egress boundary configuration');
+        }
+        return;
+    }
+    if (typeof record.resolve !== 'function')
+        throw new DecisionValidationError('unsupported egress boundary configuration');
+}
+/** Project one dispatch input and record a metadata-only `decision.project` span for it. */
+async function projectRuntimeInput(request, alias, target, input, adapter, parentSpan) {
+    const trace = runtimeTraceOf(request);
+    const started = (request.now ?? Date.now)();
+    const mode = !request.projection ? 'none'
+        : isUnprojectedLocalOptOut(request.projection) ? 'unprojected-local' : 'policy';
+    try {
+        const projected = await projectRuntimeInputUntraced(request, alias, target, input, adapter);
+        // A no-egress passthrough with no projection configured applied no D10 boundary: no span.
+        if (mode !== 'none')
+            trace?.projected(alias, parentSpan, started, { mode, outcome: 'allowed', ...(projected.evidence ? {
+                    fieldCount: projected.evidence.included.length, incompleteContext: projected.evidence.incompleteContext,
+                    automaticActionAllowed: projected.evidence.automaticActionAllowed
+                } : {}) });
+        return projected;
+    }
+    catch (error) {
+        trace?.projected(alias, parentSpan, started, { mode, outcome: 'denied',
+            ...(error instanceof DecisionProjectionError ? { reason: error.reason } : {}) });
+        throw error;
+    }
+}
+async function projectRuntimeInputUntraced(request, alias, target, input, adapter) {
+    // Read the adapter's egress declaration at dispatch time, not from planning,
+    // so a destination change after planning is still bound before credentials.
+    const egress = adapter ? (await adapter.capabilities()).egress : undefined;
+    const projection = request.projection;
+    if (!projection || isUnprojectedLocalOptOut(projection)) {
+        // Safe default: unprojected input may reach only a no-egress adapter, unless
+        // the host explicitly opted out (recorded in the result and receipt).
+        if (projection || egress?.mode === 'none')
+            return { input };
+        throw new DecisionProjectionError('data-boundary-denied', 'network-capable dispatch requires a projection policy');
+    }
+    const policy = projection.resolve({ alias, target: structuredClone(target) });
+    if (policy.provider !== target.adapter || policy.model !== target.model) {
+        throw new DecisionProjectionError('data-boundary-denied', 'projection destination does not match execution target');
+    }
+    if (egress?.mode !== 'none') {
+        // Bind the policy's declared destination to the adapter's effective transport.
+        // An adapter that cannot name its origin or region is an unknown destination.
+        if (egress?.mode !== 'network' || !egress.origin || typeof policy.origin !== 'string'
+            || normalizeProjectionOrigin(policy.origin) !== normalizeProjectionOrigin(egress.origin)) {
+            throw new DecisionProjectionError('data-boundary-denied', 'projection origin does not match the adapter endpoint');
+        }
+        if (!egress.region || policy.region !== egress.region) {
+            throw new DecisionProjectionError('data-boundary-denied', 'projection region does not match the adapter deployment');
+        }
+    }
+    const projected = await projectDecisionState(input, policy, {
+        incompleteContext: projection.incompleteContext,
+    });
+    if (!projected.evidence.automaticActionAllowed)
+        projectionBlockedAutomaticAction.add(request);
+    if (projection.debugCapture) {
+        const { scope, capture } = projection.debugCapture;
+        try {
+            await capture(scope, new TextEncoder().encode(canonicalJson(projected.state)));
+        }
+        catch {
+            // Neither backend error text nor captured bytes belong in runtime results.
+            throw new DecisionProjectionError('data-boundary-denied', 'debug capture unavailable');
+        }
+    }
+    projection.onEvidence?.({ alias, evidence: structuredClone(projected.evidence) });
+    return { input: projected.state, evidence: projected.evidence };
+}
 function interruption(context) {
     if (context.request.signal?.aborted)
         return observationFailure('cancelled', 'cancelled', undefined, 'caller-cancelled');
@@ -412,6 +1064,8 @@ function normalizeObservation(definition, target, observation) {
         validateDistribution(definition, observation.uncertainty.distribution);
     if (target.acceptance.mode === 'typed-value')
         return observation;
+    if (target.acceptance.mode === 'primitive-policy')
+        return applyPrimitiveAcceptance(definition, target.acceptance, observation);
     if (!observation.uncertainty || observation.uncertainty.confidence === null)
         return observationFailure('missing-confidence', 'abstained', observation);
     if (observation.uncertainty.profile !== target.acceptance.profile)
@@ -420,32 +1074,91 @@ function normalizeObservation(definition, target, observation) {
         return observationFailure('low-confidence', 'abstained', observation);
     return observation;
 }
-function decisionResult(context, observation, attempts) {
-    return {
+function normalizeObservationForRuntime(input) {
+    let observation = input.observation;
+    const runtime = input.request.calibrationCompatibility;
+    if (runtime && observation.status === 'success') {
+        if (observation.actualModel === null) {
+            observation = withoutCalibratedRisk(observation);
+        }
+        else {
+            const identity = runtime.identityFor({ alias: input.item.alias, definition: structuredClone(input.item.definition),
+                target: structuredClone(input.target), actualModel: observation.actualModel });
+            if (identity.actualModel !== observation.actualModel) {
+                throw new DecisionValidationError('calibration identity actual model does not match provider evidence');
+            }
+            const calibrationCompatibility = runtime.registry.resolve({
+                runId: `${input.request.runId}:${input.request.invocationId}:${input.item.alias}`,
+                requestedAlias: input.target.model,
+                actualIdentity: identity,
+                calibrationArtifactId: runtime.calibrationArtifactId,
+                at: new Date(input.now()).toISOString(),
+            }, runtime.policy);
+            observation = calibrationCompatibility.action === 'allow'
+                ? retainPinnedCalibratedRisk(observation, calibrationCompatibility)
+                : withoutCalibratedRisk(observation);
+            return { observation: normalizeObservation(input.item.definition, input.target, observation), calibrationCompatibility };
+        }
+    }
+    return { observation: normalizeObservation(input.item.definition, input.target, observation) };
+}
+function withoutCalibratedRisk(observation) {
+    if (!observation.uncertainty?.calibratedRisk)
+        return observation;
+    const uncertainty = structuredClone(observation.uncertainty);
+    delete uncertainty.calibratedRisk;
+    return { ...observation, uncertainty };
+}
+function retainPinnedCalibratedRisk(observation, pin) {
+    const risk = observation.uncertainty?.calibratedRisk;
+    if (!risk || !pin.artifactId || !pin.artifactDigest)
+        return withoutCalibratedRisk(observation);
+    const acceptedReferences = new Set([pin.artifactId, pin.artifactDigest, `${pin.artifactId}@${pin.artifactDigest}`]);
+    return acceptedReferences.has(risk.calibrationRef) ? observation : withoutCalibratedRisk(observation);
+}
+function decisionResult(context, observation, attempts, calibrationCompatibility) {
+    const result = {
         apiVersion: resultVersion(context.request), kind: 'DecisionResult',
         metadata: { id: `${context.request.invocationId}-${context.item.alias}`, version: '1.0.0', description: `Decision result for ${context.item.alias}` },
         spec: {
             decision: context.item.pin, ruleset: context.rulesetPin, binding: context.bindingPin,
             alias: context.item.alias, runId: context.request.runId, invocationId: context.request.invocationId,
             status: observation.status, ...(observation.status === 'success' ? { value: observation.value } : {}),
-            reason: observation.reason, uncertainty: observation.uncertainty, attempts,
+            reason: observation.reason, uncertainty: observation.uncertainty,
+            ...(observation.acceptance ? { acceptance: observation.acceptance } : {}), attempts,
+            ...(calibrationCompatibility ? { calibrationCompatibility } : {}),
+            ...(context.batchResult ? { batchResult: context.batchResult } : {}),
+            ...(context.contextPlan ? { context: decisionContextEvidence(context.contextPlan, context.contextUsage ?? [], decisionBatchQuestionId(context.item.alias)) } : {}),
         },
     };
+    runtimeTraceOf(context.request)?.decided(result);
+    return result;
 }
 function emptyDecisionResult(request, item, rulesetPin, bindingPin, status, reason) {
     return decisionResult({ request, item, rulesetPin, bindingPin, totalDeadline: 0, signal: new AbortController().signal,
-        totalTimeout: new AbortController().signal, attemptsAvailable: 0, now: Date.now, advance: async () => undefined }, observationFailure(reason, status), []);
+        totalTimeout: new AbortController().signal, attemptBudget: new AttemptBudget(0), now: Date.now, advance: async () => undefined }, observationFailure(reason, status), []);
 }
 function resultBase(request, ruleset, binding) {
     return {
         apiVersion: resultVersion(request), kind: 'RulesetResult',
         metadata: { id: request.invocationId, version: '1.0.0', description: `Ruleset result for ${request.ruleset.metadata.id}` },
-        spec: { ruleset, binding, runId: request.runId, invocationId: request.invocationId, status: 'error', reason: 'evaluation-failed', matchedRules: [], evaluations: {} },
+        spec: { ruleset, binding, runId: request.runId, invocationId: request.invocationId, status: 'error', reason: 'evaluation-failed', matchedRules: [], evaluations: {},
+            ...(isUnprojectedLocalOptOut(request.projection) ? { projection: { mode: 'unprojected-local', authority: 'host' } } : {}) },
     };
 }
+/**
+ * Results that can carry D04/D07 batch provenance, D05 admission, D06 context,
+ * D15 result-cache receipts or D30 provider-prefix evidence are written as v1alpha2 even from v1alpha1 inputs,
+ * so every nested result and receipt payload of one invocation shares one version.
+ */
 function resultVersion(request) {
-    if (request.ruleset.apiVersion === DECISION_API_VERSION_STRUCTURED || request.binding.apiVersion === DECISION_API_VERSION_STRUCTURED
-        || Object.values(request.definitions).some(definition => definition.apiVersion === DECISION_API_VERSION_STRUCTURED)) {
+    // The projection opt-out record and an incomplete-projection downgrade are v1alpha2-only semantics.
+    if (request.calibrationCompatibility || isUnprojectedLocalOptOut(request.projection)
+        || request.projection && !isUnprojectedLocalOptOut(request.projection) && request.projection.incompleteContext === true
+        || request.ruleset.apiVersion === DECISION_API_VERSION_STRUCTURED || request.binding.apiVersion === DECISION_API_VERSION_STRUCTURED
+        || Object.values(request.definitions).some(definition => definition.apiVersion === DECISION_API_VERSION_STRUCTURED)
+        || request.batching || request.batchReceipts || request.scheduler?.enabled || request.providerPrefix || request.context
+        || request.resultCache?.policy.enabled) {
         return DECISION_API_VERSION_STRUCTURED;
     }
     return DECISION_API_VERSION;
@@ -471,7 +1184,14 @@ function observationFailure(reason, status = reason === 'cancelled' ? 'cancelled
         ...(termination ? { termination } : {}),
     };
 }
-function toAttempt(target, ordinal, observation, durationMs) {
+function resultOnlyBatchObservations(observations) {
+    return new Map([...observations].map(([questionId, observation]) => {
+        const { requestIdSource: _requestIdSource, ...withoutRequestIdSource } = observation;
+        return [questionId, { ...withoutRequestIdSource,
+                usage: { inputTokens: null, outputTokens: null, costUsd: null }, requestId: null }];
+    }));
+}
+function toAttempt(target, ordinal, observation, durationMs, batch) {
     return {
         ordinal, adapter: target.adapter, adapterVersion: target.adapterVersion, requestedModel: target.model,
         actualModel: observation.actualModel, subagent: target.subagent ?? null, status: observation.status,
@@ -480,9 +1200,235 @@ function toAttempt(target, ordinal, observation, durationMs) {
         ...(observation.httpStatus !== undefined ? { httpStatus: observation.httpStatus } : {}),
         ...(observation.termination ? { termination: observation.termination } : {}),
         ...(observation.remoteExecution ? { remoteExecution: observation.remoteExecution } : {}),
+        ...(batch ? { batch } : {}),
+        ...(observation.admission ? { admission: observation.admission } : {}),
+        ...(observation.providerPrefix ? { providerPrefix: observation.providerPrefix } : {}),
+    };
+}
+function prepareContextPlan(request, resolved) {
+    const runtime = request.context;
+    if (!runtime)
+        return undefined;
+    const expectedIds = resolved.map(item => decisionBatchQuestionId(item.alias)).sort();
+    const suppliedIds = runtime.input.questions.map(question => question.id).sort();
+    if (!sameStringSet(expectedIds, suppliedIds)) {
+        throw new ContextPlanError('invalid-input', 'context questions must exactly cover the resolved decision evaluations');
+    }
+    if (request.batching?.enabled) {
+        for (const item of resolved) {
+            const batching = request.batching.evaluations[item.alias];
+            if (batching?.independent && batching.decisionSubject !== runtime.input.subject) {
+                throw new ContextPlanError('invalid-input', `batch subject for '${item.alias}' differs from context subject`);
+            }
+        }
+    }
+    const plan = runtime.plan ?? planDecisionContext(runtime.input, runtime.profile, runtime.estimator);
+    assertContextPlanCurrent(plan, runtime.input, runtime.profile, runtime.estimator);
+    if (runtime.rollout?.mode === 'enforce') {
+        assertContextQualified(runtime.rollout.qualification, runtime.profile, runtime.estimator);
+    }
+    else if (!runtime.rollout && (request.batching?.enabled || request.batchReceipts)) {
+        // D06 default: partitioned native batches stay closed until a rollout mode is chosen explicitly.
+        throw new ContextPlanError('rollout-unqualified', 'native batching with context planning requires rollout observe-only or a qualified enforce mode');
+    }
+    if (request.batchReceipts && request.batchReceipts.contextPlan.planDigest !== plan.planDigest) {
+        throw new ContextPlanError('stale-plan', 'batch receipt context plan differs from runtime context plan', {
+            plannedDigest: request.batchReceipts.contextPlan.planDigest, currentDigest: plan.planDigest,
+        });
+    }
+    return plan;
+}
+function batchTargetIdentity(target) {
+    return { adapter: target.adapter, adapterVersion: target.adapterVersion, model: target.model,
+        credentialRef: target.credentialRef ?? null, subagent: target.subagent ?? null,
+        timeoutMs: target.timeoutMs, retry: target.retry };
+}
+function contextPartitionedBatchPlans(plans, contextPlan) {
+    if (!contextPlan)
+        return plans;
+    const split = [];
+    for (const partition of [...contextPlan.partitions].sort((left, right) => left.wave - right.wave || left.id.localeCompare(right.id))) {
+        const permitted = new Set(partition.questionIds);
+        for (const plan of plans) {
+            if (plan.decisionSubject !== partition.subject)
+                continue;
+            const candidates = plan.candidates.filter(candidate => permitted.has(decisionBatchQuestionId(candidate.alias)));
+            if (candidates.length > 1)
+                split.push({ ...plan, candidates });
+        }
+    }
+    return split;
+}
+function recordRuntimeContextUsage(plan, questionIds, actualInputTokens, evidence) {
+    const ids = typeof questionIds === 'string' ? [questionIds] : questionIds;
+    const partition = plan.partitions.find(candidate => ids.every(id => candidate.questionIds.includes(id)));
+    if (!partition)
+        throw new ContextPlanError('invalid-input', 'request questions have no common context partition');
+    const recorded = recordContextActualUsage(plan, partition.id, actualInputTokens, ids);
+    const key = recorded.questionIds.join('\0');
+    const index = evidence.findIndex(candidate => candidate.planDigest === plan.planDigest
+        && candidate.partitionId === partition.id && candidate.questionIds.join('\0') === key);
+    if (index < 0)
+        evidence.push(recorded);
+    else
+        evidence[index] = recorded;
+}
+function contextFailureEvidence(error) {
+    const digestDetail = (value) => typeof value === 'string' && /^sha256:[0-9a-f]{64}$/.test(value) ? value : undefined;
+    const plannedDigest = digestDetail(error.details.plannedDigest);
+    const currentDigest = digestDetail(error.details.currentDigest);
+    return { schemaVersion: 'decision-context-failure/v1', reason: error.reason,
+        ...(plannedDigest ? { plannedDigest } : {}), ...(currentDigest ? { currentDigest } : {}) };
+}
+function decisionContextEvidence(plan, actualUsage, questionId) {
+    const partitionIds = questionId === undefined
+        ? new Set(plan.partitions.map(partition => partition.id))
+        : new Set(plan.partitions.filter(partition => partition.questionIds.includes(questionId)).map(partition => partition.id));
+    return { plan: structuredClone(plan), actualUsage: structuredClone(actualUsage.filter(item => partitionIds.has(item.partitionId))) };
+}
+function withRulesetContext(result, plan, usage) {
+    return { ...result, spec: { ...result.spec, context: decisionContextEvidence(plan, usage) } };
+}
+function contextUsageFromEvaluations(evaluations) {
+    const usage = new Map();
+    for (const result of Object.values(evaluations)) {
+        for (const item of result.spec.context?.actualUsage ?? []) {
+            usage.set(`${item.planDigest}\0${item.partitionId}\0${item.questionIds.join('\0')}`, structuredClone(item));
+        }
+    }
+    return [...usage.values()];
+}
+function durableBatchId(invocationId, groupId, partitionId) {
+    return `batch_${createHash('sha256').update(`${invocationId}\0${groupId}\0${partitionId}`, 'utf8').digest('hex').slice(0, 32)}`;
+}
+function durableAnswerId(batchId, questionId) {
+    return `answer_${createHash('sha256').update(`${batchId}\0${questionId}`, 'utf8').digest('hex').slice(0, 32)}`;
+}
+function sameStringSet(left, right) {
+    return left.length === right.length && left.every(value => right.includes(value));
+}
+function uniqueNonNull(values) {
+    return [...new Set(values.filter((value) => value !== null))];
+}
+function providerCost(costUsd) {
+    if (costUsd === null)
+        return null;
+    const amountMicros = Math.round(costUsd * 1_000_000);
+    return Number.isSafeInteger(amountMicros) && amountMicros >= 0
+        ? { kind: 'provider-authoritative', currency: 'USD', amountMicros }
+        : null;
+}
+function uncertainBatchAttempt(plan, started, completed) {
+    const target = plan.candidates[0].target;
+    return { ordinal: 1, adapterId: target.adapter, adapterVersion: target.adapterVersion,
+        requestedModel: target.model, actualModel: null, providerRequestId: null, status: 'execution-uncertain',
+        dispatchedAtEpochMs: started, completedAtEpochMs: completed,
+        usage: { inputTokens: null, outputTokens: null }, cost: { kind: 'unknown' }, fallbackFromAttemptOrdinal: null };
+}
+class AttemptBudget {
+    maximum;
+    consumed;
+    constructor(maximum, used = 0) {
+        this.maximum = maximum;
+        this.consumed = used;
+    }
+    get available() { return this.consumed < this.maximum; }
+    claim() { if (!this.available)
+        return false; this.consumed += 1; return true; }
+    consume(count) { this.consumed = Math.min(this.maximum, this.consumed + Math.max(0, count)); }
+}
+function effectiveConcurrency(request) {
+    const policy = request.scheduler;
+    // Receipt v2 serializes one pending dispatch. Do not weaken atomic ownership.
+    if (!policy?.enabled || request.receiptStore)
+        return 1;
+    const ceilings = [request.binding.spec.concurrency, policy.callerConcurrency, policy.graphConcurrency,
+        policy.workspace.limits.concurrency, policy.principal.limits.concurrency,
+        ...Object.values(policy.providers).map(limits => limits.concurrency)]
+        .filter((value) => value !== undefined && Number.isInteger(value) && value > 0);
+    return Math.max(1, Math.min(...ceilings));
+}
+function schedulerLane(request, item) {
+    const policy = request.scheduler;
+    if (!policy?.enabled)
+        return 'serial';
+    const target = request.binding.spec.evaluations[item.alias]?.targets[0];
+    return `${target?.adapter ?? 'none'}\u0000${policy.workspace.id}\u0000${policy.principal.id}`;
+}
+function admissionReason(error) {
+    if (error.evidence.reason === 'cancelled')
+        return 'cancelled';
+    if (error.evidence.reason === 'deadline-exceeded' || error.evidence.reason === 'queue-timeout')
+        return 'timeout';
+    if (error.evidence.reason === 'requests-per-minute' || error.evidence.reason === 'tokens-per-second'
+        || error.evidence.reason === 'retry-after')
+        return 'rate-limited';
+    if (error.evidence.reason === 'attempts' || error.evidence.reason === 'cost' || error.evidence.reason === 'unknown-cost'
+        || error.evidence.reason === 'tokens' || error.evidence.reason === 'unknown-tokens')
+        return 'budget-exhausted';
+    return 'overloaded';
+}
+function releaseAdmissionBudget(request) {
+    if (!request.scheduler?.enabled)
+        return;
+    decisionAdmissionRegistry.controller(request.scheduler.workspace.id)?.releaseBudget(request.invocationId);
+}
+function validateSchedulerPolicy(request) {
+    const policy = request.scheduler;
+    if (!policy)
+        return;
+    if (!policy.profileVersion.trim() || !policy.workspace.id.trim() || !policy.principal.id.trim()) {
+        throw new DecisionValidationError('scheduler profile version and trusted scope identities are required');
+    }
+    const limits = [policy.workspace.limits, policy.principal.limits, ...Object.values(policy.providers)];
+    if (!Object.keys(policy.providers).length || limits.some(limit => !Number.isInteger(limit.concurrency) || limit.concurrency < 1)) {
+        throw new DecisionValidationError('scheduler concurrency ceilings must be positive integers');
+    }
+    for (const value of [policy.callerConcurrency, policy.graphConcurrency]) {
+        if (value !== undefined && (!Number.isInteger(value) || value < 1))
+            throw new DecisionValidationError('scheduler caller/graph ceilings must be positive integers');
+    }
+    for (const limit of limits) {
+        for (const value of [limit.requestsPerMinute, limit.tokensPerSecond, limit.maxAttempts, limit.maxBatchSize,
+            limit.maxQueueLength, limit.maxQueueWaitMs, limit.maxRequestBytes, limit.maxItems, limit.maxRetainedWork, limit.maxTokens]) {
+            if (value !== undefined && (!Number.isFinite(value) || value < 0))
+                throw new DecisionValidationError('scheduler admission limits must be finite and non-negative');
+        }
+        if (limit.maxCostUsd !== undefined && (!Number.isFinite(limit.maxCostUsd) || limit.maxCostUsd < 0)) {
+            throw new DecisionValidationError('scheduler cost limit must be finite and non-negative');
+        }
+    }
+    if (!policy.enabled)
+        return;
+    try {
+        decisionAdmissionRegistry.register(policy, request.now ?? Date.now);
+    }
+    catch (error) {
+        if (error instanceof AdmissionProfileError)
+            throw new DecisionValidationError(error.message);
+        throw error;
+    }
+}
+function singleBatchEvidence(request, alias) {
+    if (!request.batching)
+        return undefined;
+    const configured = request.batching.evaluations[alias];
+    const target = request.binding.spec.evaluations[alias]?.targets[0];
+    const adapter = target ? request.adapters[target.adapter] : undefined;
+    const reason = !request.batching.enabled ? 'disabled'
+        : configured?.independent && (!adapter?.evaluateMany || Boolean(request.receiptStore)) ? 'unsupported' : 'ineligible';
+    return {
+        mode: 'single',
+        groupId: `single_${decisionBatchQuestionId(alias).slice(2)}`,
+        questionId: decisionBatchQuestionId(alias),
+        degradationReason: reason,
     };
 }
 function classifyValidationFailure(error) {
+    if (error instanceof ContextPlanError) {
+        return error.reason === 'stale-plan' ? 'context-plan-stale'
+            : error.reason === 'rollout-unqualified' ? 'context-unqualified' : 'invalid-input';
+    }
     if (!(error instanceof DecisionValidationError))
         return 'invalid-definition';
     if (/digest/.test(error.message))