@aiwg/cli 2026.9.24 → 2026.10.1

package/dist/src/decision/ensemble-study/statistics.js

@@ -0,0 +1,84 @@
+import { pairedBinaryDifferenceInterval, pairedMeanDifferenceBootstrap, pairedNonInferiority, wilsonScoreInterval } from '../qualification/quality.js';
+import { pairedDeltaFinding } from '../ensemble/contract.js';
+import { D17_ANALYSIS, validateD17Analysis } from './protocol.js';
+const mean = (values) => values.reduce((sum, n) => sum + n, 0) / values.length;
+const p95 = (values) => [...values].sort((a, b) => a - b)[Math.ceil(values.length * 0.95) - 1];
+/** Abstentions are false for correctness, but true events in their own paired endpoint. */
+function interval(pairs, endpoint, levelBps) {
+    const counts = { both: 0, candidateOnly: 0, baselineOnly: 0, neither: 0 };
+    for (const pair of pairs) {
+        const c = endpoint(pair.challenger), b = endpoint(pair.champion);
+        counts[c ? b ? 'both' : 'candidateOnly' : b ? 'baselineOnly' : 'neither']++;
+    }
+    return pairedBinaryDifferenceInterval({ counts, levelBps, method: 'newcombe-10' });
+}
+/** Local descriptive statistics, never a release authorization. Missing endpoints withhold native reporting. */
+export function d17Statistics(pairs, expectedIds, protocol = D17_ANALYSIS) {
+    validateD17Analysis(protocol);
+    const p = protocol;
+    if (new Set(expectedIds).size !== expectedIds.length || new Set(pairs.map(row => row.id)).size !== pairs.length
+        || pairs.some(row => !expectedIds.includes(row.id) || !p.slices.some(slice => slice === row.slice)))
+        throw new Error('D17 pair membership');
+    for (const row of pairs)
+        for (const arm of [row.champion, row.challenger]) {
+            if (typeof arm.accepted !== 'boolean' || typeof arm.correct !== 'boolean' || !arm.accepted && arm.correct
+                || [arm.probability, arm.brier].some(n => typeof n !== 'number' || !Number.isFinite(n) || n < 0 || n > 1)
+                || [arm.latencyMs, arm.reservedCostMicros].some(n => typeof n !== 'number' || !Number.isFinite(n) || n < 0)
+                || arm.tokens !== null && (!Number.isSafeInteger(arm.tokens) || arm.tokens < 0))
+                throw new Error('D17 unknown or invalid measurement');
+        }
+    const findings = [];
+    if (pairs.length !== expectedIds.length || pairs.length < p.minimumPairs)
+        findings.push('incomplete-pairs');
+    const slices = p.slices.map(slice => {
+        const rows = pairs.filter(row => row.slice === slice);
+        const delta = rows.length ? mean(rows.map(row => Number(row.challenger.correct) - Number(row.champion.correct))) : null;
+        if (rows.length < p.minimumPerSlice)
+            findings.push(`slice-insufficient:${slice}`);
+        return { slice, n: rows.length, qualityDelta: delta, harm: delta !== null && delta < 0, descriptiveOnly: true };
+    });
+    const metrics = (arm) => ({ quality: Number(arm.correct), calibration: arm.brier,
+        'risk-coverage': Number(arm.accepted && !arm.correct), abstention: Number(!arm.accepted), latency: arm.latencyMs,
+        tokens: arm.tokens, cost: arm.reservedCostMicros, slice: Number(arm.correct) });
+    const pairedDeltas = p.native.map(threshold => {
+        const complete = pairs.filter(row => metrics(row.champion)[threshold.metric] !== null && metrics(row.challenger)[threshold.metric] !== null);
+        const item = { metric: threshold.metric, pairs: complete.length, delta: complete.length ? mean(complete.map(row => metrics(row.challenger)[threshold.metric] - metrics(row.champion)[threshold.metric])) : null };
+        const finding = pairedDeltaFinding(threshold, item);
+        if (finding)
+            findings.push(finding);
+        return item;
+    });
+    const quality = pairs.length ? interval(pairs, arm => arm.correct, p.interval.levelBps) : null;
+    const abstention = pairs.length ? interval(pairs, arm => !arm.accepted, p.abstention.levelBps) : null;
+    const brier = pairs.length >= 2 ? pairedMeanDifferenceBootstrap({ differences: pairs.map(row => row.challenger.brier - row.champion.brier),
+        levelBps: p.brier.levelBps, seed: p.brier.seed, resamples: p.brier.resamples, bounds: [-1, 1] }) : null;
+    const accepted = pairs.filter(row => row.challenger.accepted), errors = accepted.filter(row => !row.challenger.correct).length;
+    const risk = accepted.length ? wilsonScoreInterval({ events: errors, n: accepted.length, levelBps: p.risk.levelBps }) : null;
+    const coverage = pairs.length ? wilsonScoreInterval({ events: accepted.length, n: pairs.length, levelBps: p.risk.levelBps }) : null;
+    const acceptedErrorUpperBps = risk ? Math.ceil(risk[1] * 10000) : null;
+    const coverageLowerBps = coverage ? Math.floor(coverage[0] * 10000) : null;
+    const p95LatencyIncreaseMs = pairs.length ? p95(pairs.map(row => row.challenger.latencyMs)) - p95(pairs.map(row => row.champion.latencyMs)) : null;
+    if (!quality || pairedNonInferiority({ interval: quality, marginBps: p.interval.nonInferiorityMarginBps }).decision !== 'non-inferior')
+        findings.push('quality-ni');
+    if (!brier || brier.upperBps > p.brier.maximumUpperBps)
+        findings.push('brier-upper');
+    if (!abstention || abstention.upperBps > p.abstention.maximumUpperBps)
+        findings.push('abstention-upper');
+    if (acceptedErrorUpperBps === null || acceptedErrorUpperBps > p.risk.maximumAcceptedErrorUpperBps)
+        findings.push('accepted-risk-upper');
+    if (coverageLowerBps === null || coverageLowerBps < p.risk.minimumCoverageLowerBps)
+        findings.push('coverage-lower');
+    if (p95LatencyIncreaseMs === null || p95LatencyIncreaseMs > p.maximumP95LatencyIncreaseMs)
+        findings.push('latency-p95');
+    const observed = new Set(pairs.map(row => row.id));
+    return { sampleN: pairs.length, missingIds: expectedIds.filter(id => !observed.has(id)), slices, pairedDeltas,
+        quality, brier, abstention, acceptedN: accepted.length, acceptedErrors: errors, acceptedErrorUpperBps, coverageLowerBps,
+        p95LatencyIncreaseMs, latencyDifferencesMs: pairs.map(row => row.challenger.latencyMs - row.champion.latencyMs),
+        netSavingsMicros: pairs.reduce((sum, row) => sum + row.champion.reservedCostMicros - row.challenger.reservedCostMicros, 0),
+        costBasis: 'nonrefundable-reservations-including-failed-attempts',
+        benefitSupported: quality !== null && quality.lowerBps > p.interval.benefitLowerExclusiveBps,
+        findings: findings.sort(), statisticalGate: findings.length ? 'HOLD' : 'pass',
+        worstCaseFailureAsError: { n: expectedIds.length, championCorrect: pairs.filter(row => row.champion.correct).length,
+            challengerCorrect: pairs.filter(row => row.challenger.correct).length, missingPairsCountedAsErrors: expectedIds.length - pairs.length } };
+}
+//# sourceMappingURL=statistics.js.map

package/dist/src/decision/evaluate.js

@@ -1,7 +1,7 @@
 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 { applyTargetAcceptance, validatePrimitiveAcceptancePolicy } from './acceptance.js';
 import { DecisionPreDispatchError, decisionInvocationFingerprint, nextReceipt } from './receipts.js';
 import { admitEntry, EntryAdmissionError } from './entry.js';
 import { correlateAtomicBatch, decisionBatchQuestionId, planNativeDecisionBatches } from './batch.js';
@@ -16,6 +16,7 @@ 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 { gatePreprocessedEvidenceDispatch, isEmptyPreprocessingLineage, isWellFormedPreprocessingLineage, PREPROCESSING_LOCAL_ORIGIN, } from './preprocessed-evidence.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';
@@ -34,6 +35,10 @@ export async function evaluateDecisionRuleset(request) {
 /** 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;
+    // A cache hit would bypass the D24 pre-dispatch lineage gate, so lineage is never cached.
+    if (preprocessingGateApplies(request)) {
+        throw new Error('Result cache does not support preprocessing lineage');
+    }
     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');
@@ -163,10 +168,15 @@ async function evaluateDecisionRulesetUngated(request) {
         rulesetPin = artifactPin(request.ruleset);
         bindingPin = artifactPin(request.binding);
         // Pin and execute immutable snapshots; adapters receive separate per-attempt copies.
+        // D24 lineage and verification are host-supplied too: the gate and the recorded
+        // result share one snapshot, so caller-owned mutation during evaluation cannot
+        // change the verdict or the recorded lineage.
         request = {
             ...request,
             ruleset: structuredClone(request.ruleset), binding: structuredClone(request.binding),
             definitions: structuredClone(request.definitions), input: structuredClone(request.input),
+            preprocessingLineage: snapshotPreprocessingLineage(request.preprocessingLineage),
+            preprocessingVerification: snapshotPreprocessingVerification(request.preprocessingVerification),
         };
         base = resultBase(request, rulesetPin, bindingPin);
         validateBinding(request.binding, request.ruleset);
@@ -195,6 +205,19 @@ async function evaluateDecisionRulesetUngated(request) {
     if (contextPlan)
         base = withRulesetContext(base, contextPlan, []);
     runtimeTraceOf(request)?.validated(false);
+    // D24: stored preprocessing lineage is gated before receipts, credentials and transport.
+    if (preprocessingGateApplies(request)) {
+        const gate = gatePreprocessedEvidenceDispatch(request.preprocessingLineage, request.preprocessingVerification, resolved.flatMap(item => request.binding.spec.evaluations[item.alias].targets
+            .map(target => preprocessingDestination(request, item.alias, target))), request.input, request.ruleset.spec.evaluations.map(evaluation => evaluation.inputPointer));
+        base = { ...base, spec: { ...base.spec, preprocessingLineage: base.spec.preprocessingLineage
+                    ? { ...base.spec.preprocessingLineage, dispatchGate: gate }
+                    : { schemaVersion: 'decision-preprocessing-lineage/v1', status: 'review', references: [], traces: [], dispatchGate: gate } } };
+        if (gate.outcome === 'refused')
+            return failureResult(base, 'data-boundary-denied');
+        if (gate.outcome === 'review') {
+            return { ...base, spec: { ...base.spec, status: 'review', reason: 'insufficient-information', matchedRules: [], evaluations: {} } };
+        }
+    }
     const batchPolicy = request.batchReceipts;
     if (batchPolicy?.unknownCostBound && (!Number.isSafeInteger(batchPolicy.unknownCostBound.upperBoundMicros)
         || batchPolicy.unknownCostBound.upperBoundMicros < 0 || !batchPolicy.unknownCostBound.policyId
@@ -205,6 +228,14 @@ async function evaluateDecisionRulesetUngated(request) {
         || batchPolicy.unknownCostBound.upperBoundMicros > batchPolicy.maxCostMicros)) {
         return failureResult(base, 'budget-exhausted');
     }
+    // #2797: a context-planned invocation clones the full plan into every evaluation, so the
+    // completed result can exceed entry admission after provider work. Preflight the worst-case
+    // completion envelope here — before receipts, credentials, admission control and transport —
+    // and reject without dispatch when no completion could be admissible.
+    if (contextPlan && !contextResultEnvelopeFits(contextPlan, resolved, request.binding)) {
+        const rejected = failureResult(base, 'invalid-input');
+        return { ...rejected, spec: { ...rejected.spec, contextFailure: { schemaVersion: 'decision-context-failure/v1', reason: 'invalid-input' } } };
+    }
     const fingerprint = decisionInvocationFingerprint({
         invocationId: request.invocationId,
         value: request.input,
@@ -437,10 +468,24 @@ async function evaluateDecisionRulesetUngated(request) {
                         const batchSpan = runtimeTraceOf(request)?.startBatch(plan.candidates.map(candidate => candidate.alias), plan.groupId, durableReceipt ? durableReceipt.attempts.length + 1 : dispatchCount);
                         if (batchSpan)
                             batchSpans.push(batchSpan);
+                        // A request owns its usage even when it fails before an answer is available.
+                        // Durable mode already has that owner in its batch receipt.
+                        const usageOwner = !durableReceipt ? {
+                            groupId: plan.groupId, ordinal: dispatchCount, questionIds: [...questionIds],
+                            usage: { inputTokens: null, outputTokens: null, costUsd: null },
+                            requestId: null,
+                        } : undefined;
+                        if (usageOwner)
+                            (base.spec.batchRequests ??= []).push(usageOwner);
                         const response = await adapter.evaluateMany({ decisionSubject: plan.decisionSubject,
                             requests: preparedRequests, ...(batchSpan ? { traceContext: batchSpan.traceContext } : {}) });
                         if (batchSpan)
                             batchSpan.response = response;
+                        if (usageOwner) {
+                            usageOwner.usage = structuredClone(response.sharedUsage);
+                            const ids = uniqueNonNull(response.answers.map(answer => answer.observation.requestId));
+                            usageOwner.requestId = ids.length === 1 && validOpaqueRequestId(ids[0]) ? ids[0] : null;
+                        }
                         if (contextPlan && response.sharedUsage.inputTokens !== null) {
                             recordRuntimeContextUsage(contextPlan, questionIds, response.sharedUsage.inputTokens, contextUsage);
                         }
@@ -581,6 +626,8 @@ async function evaluateDecisionRulesetUngated(request) {
                     }
                 }
                 runtimeTraceOf(request)?.finishBatch(batchSpans, durableReceipt);
+                // Both durable and result-owned native requests keep accounting off answers.
+                observations = resultOnlyBatchObservations(observations);
                 plan.candidates.forEach((candidate, index) => {
                     const item = resolved.find(value => value.alias === candidate.alias);
                     const evidence = { mode: 'native', groupId: plan.groupId, questionId: questionIds[index] };
@@ -920,6 +967,65 @@ async function invokeWithDeadline(context, adapter, target, deadlineEpochMs, ord
 }
 /** Requests whose projection evidence prohibited automatic action (allowed incomplete context). */
 const projectionBlockedAutomaticAction = new WeakSet();
+/**
+ * D24 snapshot of host-supplied lineage. Uncloneable content cannot be well-formed
+ * lineage, so it is passed through for the gate to refuse exactly as before.
+ */
+function snapshotPreprocessingLineage(lineage) {
+    if (lineage === undefined)
+        return undefined;
+    try {
+        return structuredClone(lineage);
+    }
+    catch {
+        return lineage;
+    }
+}
+/**
+ * D24 snapshot of host-supplied verification. Manifests, lifecycle and bindings are
+ * data and snapshotted with the lineage; `now` is host code and carried by reference
+ * like the other request callbacks. Uncloneable data is passed through for the gate
+ * to judge.
+ */
+function snapshotPreprocessingVerification(verification) {
+    if (verification === undefined)
+        return undefined;
+    const { now, ...rest } = verification;
+    try {
+        const snapshot = structuredClone(rest);
+        return now === undefined ? snapshot : { ...snapshot, now };
+    }
+    catch {
+        return verification;
+    }
+}
+/**
+ * D24 applies when lineage is supplied or the host supplied verification expecting lineage.
+ * Requests with neither keep the text-native path unchanged.
+ */
+function preprocessingGateApplies(request) {
+    return !isEmptyPreprocessingLineage(request.preprocessingLineage) || request.preprocessingVerification !== undefined;
+}
+/**
+ * The D10 destination a target would send derived text to: the projection policy's provider and
+ * origin, or the local no-egress destination when no projection is configured (projection then
+ * denies any network adapter before credentials). `null` means the destination cannot be bound.
+ */
+function preprocessingDestination(request, alias, target) {
+    const projection = request.projection;
+    if (!projection)
+        return { provider: target.adapter, origin: PREPROCESSING_LOCAL_ORIGIN };
+    if (isUnprojectedLocalOptOut(projection))
+        return null;
+    try {
+        const policy = projection.resolve({ alias, target: structuredClone(target) });
+        return typeof policy?.provider === 'string' && typeof policy.origin === 'string'
+            ? { provider: policy.provider, origin: policy.origin } : null;
+    }
+    catch {
+        return null;
+    }
+}
 function isUnprojectedLocalOptOut(projection) {
     return !!projection && projection.mode === 'unprojected-local';
 }
@@ -1062,17 +1168,7 @@ function normalizeObservation(definition, target, observation) {
     validateDecisionValue(definition, observation.value);
     if (observation.uncertainty?.distribution)
         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)
-        return observationFailure('confidence-profile-mismatch', 'abstained', observation);
-    if (observation.uncertainty.confidence * 10_000 < target.acceptance.minimumBps)
-        return observationFailure('low-confidence', 'abstained', observation);
-    return observation;
+    return applyTargetAcceptance(definition, target, observation);
 }
 function normalizeObservationForRuntime(input) {
     let observation = input.observation;
@@ -1143,7 +1239,10 @@ function resultBase(request, ruleset, binding) {
         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: {},
-            ...(isUnprojectedLocalOptOut(request.projection) ? { projection: { mode: 'unprojected-local', authority: 'host' } } : {}) },
+            ...(isUnprojectedLocalOptOut(request.projection) ? { projection: { mode: 'unprojected-local', authority: 'host' } } : {}),
+            // Only a lineage the D24 gate can read is copied; a malformed one is recorded by the gate as refused.
+            ...(!isEmptyPreprocessingLineage(request.preprocessingLineage) && isWellFormedPreprocessingLineage(request.preprocessingLineage)
+                ? { preprocessingLineage: structuredClone(request.preprocessingLineage) } : {}) },
     };
 }
 /**
@@ -1158,7 +1257,7 @@ function resultVersion(request) {
         || 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) {
+        || request.resultCache?.policy.enabled || preprocessingGateApplies(request)) {
         return DECISION_API_VERSION_STRUCTURED;
     }
     return DECISION_API_VERSION;
@@ -1259,6 +1358,120 @@ function contextPartitionedBatchPlans(plans, contextPlan) {
     }
     return split;
 }
+/**
+ * Pre-dispatch worst-case bound (#2797) on the completed result envelope of a context-planned
+ * invocation.
+ *
+ * Every evaluation carries one full clone of the context plan alongside the ruleset-level plan,
+ * so the envelope grows with the alias count even when the provider request fits. Usage is
+ * recorded cumulatively as evaluations complete — evaluation i carries i+1 usage entries — and
+ * entries are upserted by key, so retries add none; every evaluation carrying all n entries is
+ * therefore the true upper bound. Attempts are bounded per alias by the binding: no alias can
+ * record more than its targets' retries plus one, nor more than the invocation-wide maxAttempts.
+ * Each probe attempt carries the same evidence a real single dispatch records (requestIdSource
+ * and the single-dispatch batch object), and each probe distribution spans the definition's full
+ * answer domain. Entry admission is monotonic in every counted dimension, so a probe that cannot
+ * satisfy admission proves no completion of the invocation could either; the caller must then
+ * reject before receipts, credentials, admission control or transport instead of discarding
+ * completed provider work after dispatch. A fitting envelope still passes through writer-version
+ * admission when the completed result is written. Null, unknown or non-safe-integer counts fail
+ * closed.
+ */
+export function contextResultEnvelopeFits(plan, items, binding) {
+    if (!binding || !Number.isSafeInteger(binding.spec?.maxAttempts) || binding.spec.maxAttempts < 1)
+        return false;
+    for (const item of items) {
+        const configured = binding.spec.evaluations?.[item.alias];
+        if (!configured || !Array.isArray(configured.targets) || !configured.targets.length)
+            return false;
+        let perAlias = 0;
+        for (const target of configured.targets) {
+            const maxRetries = target?.retry?.maxRetries;
+            if (!Number.isSafeInteger(maxRetries) || maxRetries < 0)
+                return false;
+            perAlias += maxRetries + 1;
+        }
+        if (!Number.isSafeInteger(perAlias) || Math.min(binding.spec.maxAttempts, perAlias) < 1)
+            return false;
+        if (contextResultEnvelopeDistributionKeys(item.definition).length === 0)
+            return false;
+    }
+    try {
+        admitEntry(contextResultEnvelopeProbe(plan, items, binding));
+        return true;
+    }
+    catch (error) {
+        if (error instanceof EntryAdmissionError)
+            return false;
+        throw error;
+    }
+}
+/** Answer-domain keys of a definition, matching distribution validation support. */
+function contextResultEnvelopeDistributionKeys(definition) {
+    const answer = definition?.spec?.answer;
+    if (!answer)
+        return [];
+    if (answer.kind === 'choice')
+        return answer.options.map(option => option.id);
+    if (answer.kind === 'ordinal-score')
+        return answer.levels.map((_, index) => String(index));
+    return ['false', 'true'];
+}
+function contextResultEnvelopeProbe(plan, items, binding) {
+    const pin = (id) => ({ id, version: '1.0.0', digest: `sha256:${'0'.repeat(64)}` });
+    const firstPartition = plan.partitions[0];
+    const usageFor = (alias) => firstPartition && firstPartition.questionIds.length
+        ? recordContextActualUsage(plan, firstPartition.id, 0, firstPartition.questionIds.includes(alias) ? alias : firstPartition.questionIds[0])
+        : { schemaVersion: 'decision-context-usage/v1', planDigest: plan.planDigest, partitionId: 'probe', questionIds: [alias],
+            estimator: { ...plan.estimator }, providerProfile: { id: plan.providerProfile.id, version: plan.providerProfile.version },
+            estimatedInputTokens: 0, actualInputTokens: 0, estimationErrorTokens: 0, estimationErrorBps: null };
+    // Worst case: every evaluation carries every usage entry (cumulative recording, upserted by key).
+    const usages = items.map(item => usageFor(item.alias));
+    const evaluations = Object.fromEntries(items.map(item => {
+        const configured = binding.spec.evaluations[item.alias];
+        const target = configured.targets[0];
+        const questionId = decisionBatchQuestionId(item.alias);
+        let perAlias = 0;
+        for (const candidate of configured.targets)
+            perAlias += candidate.retry.maxRetries + 1;
+        const attemptCount = Math.min(binding.spec.maxAttempts, perAlias);
+        const keys = contextResultEnvelopeDistributionKeys(item.definition);
+        const peak = keys.reduce((longest, key) => key.length >= longest.length ? key : longest, keys[0]);
+        const value = item.definition.spec.answer.kind === 'ordinal-score' ? Number(peak)
+            : item.definition.spec.answer.kind === 'choice' ? peak : peak === 'true';
+        const distribution = Object.fromEntries(keys.map(key => [key, key === peak ? 1 : 0]));
+        const attempts = Array.from({ length: attemptCount }, (_, index) => ({
+            ordinal: index + 1, adapter: target.adapter, adapterVersion: target.adapterVersion,
+            requestedModel: target.model, actualModel: target.model,
+            subagent: target.subagent ?? null, status: 'success', reason: 'none', durationMs: 0,
+            usage: { inputTokens: 0, outputTokens: 0, costUsd: null },
+            requestId: 'probe', requestIdSource: 'typesafe', httpStatus: 200,
+            // A retried attempt records its backoff; only the final attempt has none.
+            ...(index < attemptCount - 1 ? { retryDelayMs: 0 } : {}),
+            // Single-dispatch evidence, as recorded when native batching does not apply. The native
+            // batch object carries a subset of these fields, so the single shape bounds both phases.
+            batch: { mode: 'single', groupId: `single_${questionId.slice(2)}`, questionId, degradationReason: 'unsupported' },
+        }));
+        return [item.alias, {
+                apiVersion: DECISION_API_VERSION_STRUCTURED, kind: 'DecisionResult',
+                metadata: { id: `context-result-envelope-probe-${item.alias}`, version: '1.0.0', description: `Decision result for ${item.alias}` },
+                spec: { decision: pin(`probe-${item.alias}`), ruleset: pin('probe-ruleset'), binding: pin('probe-binding'),
+                    alias: item.alias, runId: 'context-result-envelope-probe', invocationId: 'context-result-envelope-probe',
+                    status: 'success', value, reason: 'none',
+                    uncertainty: { source: 'provider', profile: 'typesafe-distribution-v1', calibration: 'vendor-claimed', confidence: 1,
+                        distribution, calibrationRef: null },
+                    attempts, context: { plan: structuredClone(plan), actualUsage: usages.map(usage => structuredClone(usage)) } },
+            }];
+    }));
+    return { apiVersion: DECISION_API_VERSION_STRUCTURED, kind: 'RulesetResult',
+        metadata: { id: 'context-result-envelope-probe', version: '1.0.0', description: 'Context result envelope probe' },
+        // A matched completion carries its outcome and matched rule ids; ruleset-declared outcomes are
+        // bounded by artifact admission of the ruleset itself, so the probe carries representative ones.
+        spec: { ruleset: pin('probe-ruleset'), binding: pin('probe-binding'), runId: 'context-result-envelope-probe',
+            invocationId: 'context-result-envelope-probe', status: 'completed', reason: 'none', matchedRules: ['review'],
+            outcome: 'review',
+            evaluations, context: { plan: structuredClone(plan), actualUsage: usages } } };
+}
 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)));

package/dist/src/decision/export.js

@@ -3,6 +3,10 @@ export function decisionResultForExport(result, policy = {}) {
     const copy = structuredClone(result);
     if (policy.includeProviderRequestIds)
         return copy;
+    if (copy.kind === 'RulesetResult') {
+        for (const request of copy.spec.batchRequests ?? [])
+            request.requestId = null;
+    }
     const decisions = copy.kind === 'DecisionResult'
         ? [copy] : Object.values(copy.spec.evaluations);
     for (const decision of decisions) {