@aiwg/cli 2026.9.21 → 2026.10.0

package/dist/src/decision/adapters/jev.js

@@ -34,6 +34,7 @@ export class JevDecisionAdapter {
     pinnedFetch;
     now;
     region;
+    observeResponseBody;
     constructor(options = {}) {
         this.endpoint = options.endpoint ?? JEV_ENDPOINT;
         this.fetchImpl = options.fetch ?? fetch;
@@ -42,6 +43,23 @@ export class JevDecisionAdapter {
         this.pinnedFetch = options.pinnedFetch ?? pinnedHttpsFetch;
         this.now = options.now ?? Date.now;
         this.region = options.region?.trim() ? options.region : null;
+        this.observeResponseBody = options.observeResponseBody;
+    }
+    observeResponse(body) {
+        if (!this.observeResponseBody)
+            return;
+        let parsed = {};
+        try {
+            parsed = asRecord(parseBoundedJson(body));
+        }
+        catch { /* Invalid answers still have bounded body evidence. */ }
+        let usage = emptyUsage();
+        try {
+            usage = normalizeUsage(parsed.usage);
+        }
+        catch { /* Missing usage is unknown, including on auth errors. */ }
+        this.observeResponseBody(body, { actualModel: typeof parsed.model === 'string' && parsed.model ? parsed.model : null,
+            usage });
     }
     async capabilities() {
         return {
@@ -167,6 +185,7 @@ export class JevDecisionAdapter {
         if (!response.ok) {
             try {
                 const errorBody = await readBoundedBody(response, signal);
+                this.observeResponse(errorBody);
                 if (!metadata.requestId && response.headers.get('content-type')?.includes('json')) {
                     let parsedError;
                     try {
@@ -198,6 +217,7 @@ export class JevDecisionAdapter {
         let parsed;
         try {
             const encoded = await readBoundedBody(response, signal);
+            this.observeResponse(encoded);
             parsed = parseBoundedJson(encoded);
             if (request.signal.aborted)
                 return externalInterruption(request, 'terminal-response', metadata);
@@ -304,7 +324,7 @@ export class JevDecisionAdapter {
         }
         if (!response.ok) {
             try {
-                await readBoundedBody(response, signal);
+                this.observeResponse(await readBoundedBody(response, signal));
             }
             catch {
                 return batchFailure(requests, failure('invalid-output', metadata));
@@ -313,7 +333,9 @@ export class JevDecisionAdapter {
             return batchFailure(requests, failure(mapStatus(response.status), { ...metadata, ...(retryAfterMs === null ? {} : { retryAfterMs }) }));
         }
         try {
-            const parsed = parseBoundedJson(await readBoundedBody(response, signal));
+            const encoded = await readBoundedBody(response, signal);
+            this.observeResponse(encoded);
+            const parsed = parseBoundedJson(encoded);
             const normalized = normalizeBatchResponse(requests, parsed).map(answer => ({
                 questionId: answer.questionId,
                 observation: { ...answer.observation, ...metadata },

package/dist/src/decision/calibration/registry.js

@@ -88,6 +88,11 @@ export class CalibrationRegistry {
         const rollback = history.find(event => event.revision === eligibility.rollbackTarget.aliasRevision);
         if (!rollback || rollback.actualIdentityDigest !== eligibility.rollbackTarget.identityDigest)
             throw new CalibrationRegistryError('rollback target no longer matches immutable alias history');
+        const current = history.at(-1);
+        if (current !== rollback || current.kind === 'retired')
+            throw new CalibrationRegistryError('alias no longer holds the champion this promotion was approved to replace');
+        if (history.some(event => event.promotionEligibilityId === eligibility.id))
+            throw new CalibrationRegistryError(`promotion eligibility '${eligibility.id}' was already used`);
         const event = immutable({ revision: history.length + 1, alias: eligibility.alias,
             actualIdentityDigest: eligibility.candidateIdentityDigest, actualModel: eligibility.candidateActualModel, recordedAt: new Date(validDate(at)).toISOString(),
             kind: 'promoted', promotionEligibilityId: eligibility.id });
@@ -172,6 +177,7 @@ export class CalibrationRegistry {
     aliasHistory(alias) { return structuredClone(this.aliases.get(alias) ?? []); }
     driftEvents(alias) { return structuredClone(alias ? this.drift.filter(event => event.alias === alias) : this.drift); }
     promotionHistory() { return structuredClone([...this.eligibility.values()]); }
+    promotionEligibility(id) { const record = this.eligibility.get(id); return record ? structuredClone(record) : null; }
     artifactHistory() { return structuredClone([...this.artifacts.values()]); }
     compatibilityHistory() { return structuredClone(this.relations); }
 }
@@ -190,6 +196,9 @@ function calibrationUsability(artifact, at) {
         reasons.push('calibration-bound-exceeded');
     if (artifact.metrics.selectiveRisk > artifact.profile.maximumSelectiveRisk)
         reasons.push('selective-risk-bound-exceeded');
+    // An artifact is unusable before it takes effect: a back-dated request cannot borrow a later calibration.
+    if (validDate(at) < validDate(artifact.effectiveAt))
+        reasons.push('calibration-not-yet-effective');
     if (validDate(at) >= validDate(artifact.effectiveAt) + artifact.profile.expiresAfterDays * 86_400_000)
         reasons.push('calibration-expired');
     return reasons;

package/dist/src/decision/compose.js

@@ -1,7 +1,16 @@
 import { evaluatePredicate } from './predicates.js';
 import { validateAgainstSchema } from './validate.js';
 export function composeRuleset(ruleset, input, evaluations) {
-    const failed = Object.values(evaluations).some(result => result.spec.status !== 'success');
+    const referencedAliases = referencedDecisionAliases(ruleset);
+    const requiredEvaluations = new Map(ruleset.spec.evaluations
+        .filter(evaluation => referencedAliases.includes(evaluation.alias))
+        .map(evaluation => [evaluation.alias, evaluation]));
+    const suppliedFailed = Object.values(evaluations).some(result => !acceptedEvaluation(result));
+    const requiredFailed = [...requiredEvaluations].some(([alias, evaluation]) => {
+        const result = evaluations[alias];
+        return !result || result.spec.alias !== alias || !acceptedEvaluation(result) || !samePin(result.spec.decision, evaluation.decision);
+    });
+    const failed = suppliedFailed || requiredFailed;
     if (failed) {
         validateAgainstSchema(ruleset.spec.outputSchema, ruleset.spec.failureOutcome, 'failureOutcome');
         return {
@@ -18,31 +27,81 @@ export function composeRuleset(ruleset, input, evaluations) {
         validateAgainstSchema(ruleset.spec.outputSchema, ruleset.spec.defaultOutcome, 'defaultOutcome');
         return { status: 'defaulted', reason: 'no-match', outcome: structuredClone(ruleset.spec.defaultOutcome), matchedRules: [] };
     }
-    if (ruleset.spec.composition === 'collect') {
-        const outcome = matches.map(rule => structuredClone(rule.outcome));
+    if (ruleset.spec.composition === 'collect' || ruleset.spec.composition.startsWith('collect-')) {
+        const collected = matches.map(rule => structuredClone(rule.outcome));
+        const outcome = ruleset.spec.composition === 'collect' ? collected : aggregateCollect(collected, ruleset.spec.composition);
         validateAgainstSchema(ruleset.spec.outputSchema, outcome, 'collected outcome');
         return { status: 'completed', reason: 'none', outcome, matchedRules: matches.map(rule => rule.id) };
     }
+    if (ruleset.spec.composition === 'unique' && matches.length > 1)
+        return conflictResult(ruleset, matches);
+    if (ruleset.spec.composition === 'any') {
+        const first = sortJson(matches[0].outcome);
+        if (matches.some(rule => JSON.stringify(sortJson(rule.outcome)) !== JSON.stringify(first)))
+            return conflictResult(ruleset, matches);
+        const outcome = structuredClone(matches[0].outcome);
+        validateAgainstSchema(ruleset.spec.outputSchema, outcome, 'matched outcome');
+        return { status: 'completed', reason: 'none', outcome, matchedRules: matches.map(rule => rule.id) };
+    }
     const top = matches.filter(rule => rule.priority === matches[0].priority);
     const unique = new Map();
     for (const rule of top)
         unique.set(JSON.stringify(sortJson(rule.outcome)), rule.outcome);
-    if (unique.size > 1) {
-        if (ruleset.spec.conflict === 'review') {
-            validateAgainstSchema(ruleset.spec.outputSchema, ruleset.spec.failureOutcome, 'failureOutcome');
-            return {
-                status: 'review',
-                reason: 'conflicting-outcomes',
-                outcome: structuredClone(ruleset.spec.failureOutcome),
-                matchedRules: top.map(rule => rule.id),
-            };
-        }
-        return { status: 'error', reason: 'conflicting-outcomes', matchedRules: top.map(rule => rule.id) };
-    }
+    if (unique.size > 1)
+        return conflictResult(ruleset, top);
     const outcome = structuredClone(top[0].outcome);
     validateAgainstSchema(ruleset.spec.outputSchema, outcome, 'matched outcome');
     return { status: 'completed', reason: 'none', outcome, matchedRules: top.map(rule => rule.id) };
 }
+function acceptedEvaluation(result) {
+    return result.spec.status === 'success'
+        && (result.spec.acceptance === undefined || result.spec.acceptance.disposition === 'act');
+}
+function samePin(left, right) {
+    return left.id === right.id && left.version === right.version && left.digest === right.digest;
+}
+function referencedDecisionAliases(ruleset) {
+    const aliases = new Set();
+    const visit = (predicate) => {
+        if ('all' in predicate)
+            predicate.all.forEach(visit);
+        else if ('any' in predicate)
+            predicate.any.forEach(visit);
+        else if ('not' in predicate)
+            visit(predicate.not);
+        else if (predicate.left.source === 'decision' && predicate.left.alias)
+            aliases.add(predicate.left.alias);
+    };
+    ruleset.spec.rules.forEach(rule => visit(rule.when));
+    return [...aliases].sort();
+}
+function conflictResult(ruleset, matches) {
+    if (ruleset.spec.conflict === 'review') {
+        validateAgainstSchema(ruleset.spec.outputSchema, ruleset.spec.failureOutcome, 'failureOutcome');
+        return {
+            status: 'review',
+            reason: 'conflicting-outcomes',
+            outcome: structuredClone(ruleset.spec.failureOutcome),
+            matchedRules: matches.map(rule => rule.id),
+        };
+    }
+    return { status: 'error', reason: 'conflicting-outcomes', matchedRules: matches.map(rule => rule.id) };
+}
+function aggregateCollect(values, composition) {
+    if (composition === 'collect-count')
+        return values.length;
+    if (!values.every(value => typeof value === 'number' && Number.isFinite(value))) {
+        throw new Error(`${composition} requires finite numeric outcomes`);
+    }
+    const numbers = values;
+    if (composition === 'collect-sum')
+        return numbers.reduce((sum, value) => sum + value, 0);
+    if (composition === 'collect-min')
+        return Math.min(...numbers);
+    if (composition === 'collect-max')
+        return Math.max(...numbers);
+    return values;
+}
 function sortJson(value) {
     if (Array.isArray(value))
         return value.map(sortJson);

package/dist/src/decision/context-live-promotion.js

@@ -0,0 +1,344 @@
+/**
+ * TV-12 promotion steps after collection (#2681): record the reviewer-approved profile and margin chosen
+ * by the preregistered rule, then run an enforce-mode canary with an exercised rollback to single calls.
+ * Neither step changes a default: enforcement still needs a caller to pass the recorded qualification.
+ */
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { canonicalJson } from '../security/artifact-trust.js';
+import { admitEntry } from './entry.js';
+import { CanonicalJsonByteEstimator, ContextPlanError, planDecisionContext } from './context-plan.js';
+import { assertContextQualified, compareContextUsage } from './context-qualification.js';
+import { assertContextArtifactRoot, assertContextLiveSource, compileContextLiveCase, contextLiveBinding, contextLiveDigest, contextLiveRequestCapacity, contextLiveRuleset, contextLiveTarget, ContextLiveBudget, validateContextLiveApproval, withContextLiveSpendLedger, TV12_ISSUE_USD_CAP, CREDENTIAL_REF, } from './context-live-qualification.js';
+import { JevDecisionAdapter } from './adapters/jev.js';
+import { decisionBatchQuestionId } from './batch.js';
+import { contextResultEnvelopeFits, evaluateDecisionRuleset } from './evaluate.js';
+const estimator = new CanonicalJsonByteEstimator();
+const subject = 'synthetic-tv12';
+const nonblank = (value) => typeof value === 'string' && value.trim().length > 0;
+const sha256 = /^sha256:[a-f0-9]{64}$/;
+const closed = (value, keys) => !!value && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).sort().join(',') === [...keys].sort().join(',');
+export const contextLiveRecordsDigest = (records) => contextLiveDigest([...records]
+    .sort((a, b) => `${a.caseId}\0${a.partitionId}`.localeCompare(`${b.caseId}\0${b.partitionId}`, 'en')));
+/** Rebinds every retained comparison to the frozen corpus and returns exactly one complete provider request per partition. */
+async function boundComparisons(approval, corpus, records) {
+    const samples = [];
+    const used = new Set();
+    for (const item of corpus.cases) {
+        const { input } = await compileContextLiveCase(item, approval.model, approval.region);
+        let plan;
+        try {
+            plan = planDecisionContext(input, corpus.profile, estimator);
+        }
+        catch (error) {
+            if (error instanceof ContextPlanError && ['oversized-state', 'oversized-question'].includes(error.reason))
+                continue;
+            throw error;
+        }
+        for (const partition of plan.partitions) {
+            const partitionInput = { ...input, questions: input.questions.filter(q => partition.questionIds.includes(q.id)) };
+            const checked = planDecisionContext(partitionInput, corpus.profile, estimator);
+            const matches = records.filter(r => r.caseId === item.id && r.partitionId === partition.id);
+            const record = matches[0];
+            const usage = record && { source: record.source, servedModel: record.servedModel, requestId: record.requestId,
+                inputTokens: record.inputTokens, outputTokens: record.outputTokens, costUsd: record.costUsd };
+            if (matches.length !== 1 || !record || checked.partitions.length !== 1 || record.source !== 'provider' || record.servedModel !== approval.model
+                || record.planDigest !== checked.planDigest || record.profileDigest !== checked.providerProfile.digest
+                || record.estimator.id !== estimator.id || record.estimator.version !== estimator.version
+                || record.estimatedInputTokens !== checked.partitions[0].estimate.aggregateTokens
+                || record.actualInputTokens !== record.inputTokens || record.usageArtifactDigest !== contextLiveDigest(usage)
+                || record.usageRef !== `usage:${record.usageArtifactDigest}`) {
+                throw new ContextPlanError('invalid-input', 'retained comparison does not bind to the frozen corpus partition');
+            }
+            used.add(record);
+            samples.push({ caseId: `${item.id}:${partition.id}`, input: partitionInput, actualInputTokens: record.actualInputTokens, source: 'provider', usageRef: record.usageRef });
+        }
+    }
+    if (!samples.length || used.size !== records.length)
+        throw new ContextPlanError('invalid-input', 'retained comparisons must cover exactly the planned partitions');
+    return samples;
+}
+/**
+ * Applies the preregistered rule (worst observed undercount plus the frozen reserve, capped by the frozen
+ * maximum) and records the reviewer's matching approval. Synthetic, partial or unbound evidence throws.
+ */
+export async function recordContextQualification(options) {
+    const approval = structuredClone(options.approval), corpus = structuredClone(options.corpus);
+    const records = structuredClone(options.records), review = structuredClone(options.review);
+    validateContextLiveApproval(approval, corpus);
+    admitEntry(review);
+    const { marginRule } = approval;
+    // A selected margin above the collection margin could split a request that was collected whole.
+    if (corpus.profile.safetyMarginBps < marginRule.maximumMarginBps)
+        throw new ContextPlanError('invalid-profile', 'collection margin must cover the preregistered maximum');
+    const samples = await boundComparisons(approval, corpus, records);
+    const observed = compareContextUsage(samples, corpus.profile, estimator);
+    for (const row of observed.cases) {
+        const [caseId, partitionId] = row.caseId.split(':');
+        if (records.find(r => r.caseId === caseId && r.partitionId === partitionId).undercountBps !== row.undercountBps) {
+            throw new ContextPlanError('invalid-input', 'retained undercount differs from recomputation');
+        }
+    }
+    const candidateMarginBps = observed.worstUndercountBps + marginRule.extraReserveBps;
+    if (candidateMarginBps > marginRule.maximumMarginBps) {
+        throw new ContextPlanError('rollout-unqualified', 'observed undercount exceeds the preregistered maximum margin');
+    }
+    const recordsDigest = contextLiveRecordsDigest(records);
+    if (!closed(review, ['schemaVersion', 'approved', 'reviewer', 'approvalReference', 'runId', 'recordsDigest', 'selectedMarginBps', 'qualifiedProfile'])
+        || !closed(review.qualifiedProfile, ['id', 'version']) || review.schemaVersion !== 'context-margin-review/v1' || review.approved !== true
+        || !nonblank(review.reviewer) || !nonblank(review.approvalReference) || review.runId !== approval.runId || review.recordsDigest !== recordsDigest
+        || review.selectedMarginBps !== candidateMarginBps || !nonblank(review.qualifiedProfile.id) || !nonblank(review.qualifiedProfile.version)
+        || review.qualifiedProfile.id === corpus.profile.id && review.qualifiedProfile.version === corpus.profile.version) {
+        throw new ContextPlanError('rollout-unqualified', 'margin review does not approve the preregistered selection for these records');
+    }
+    const profile = { ...structuredClone(corpus.profile), id: review.qualifiedProfile.id,
+        version: review.qualifiedProfile.version, safetyMarginBps: candidateMarginBps };
+    const qualification = compareContextUsage(samples, profile, estimator);
+    assertContextQualified(qualification, profile, estimator);
+    return { schemaVersion: 'context-qualification-record/v1', runId: approval.runId, sourceCommit: approval.sourceCommit,
+        model: approval.model, region: approval.region, corpusDigest: approval.corpusDigest, preregistrationDigest: approval.preregistrationDigest,
+        approvalDigest: contextLiveDigest(approval), recordsDigest, collectionProfileDigest: contextLiveDigest(corpus.profile), marginRule,
+        selection: { worstUndercountBps: observed.worstUndercountBps, extraReserveBps: marginRule.extraReserveBps, candidateMarginBps,
+            maximumMarginBps: marginRule.maximumMarginBps }, review, profile, profileDigest: contextLiveDigest(profile), qualification };
+}
+/** Enforcement gate for a stored record. Any profile change, including only its version, invalidates it. */
+export function verifyContextQualificationRecord(record, profile = record?.profile) {
+    const s = record?.selection;
+    if (record?.schemaVersion !== 'context-qualification-record/v1' || !s || s.candidateMarginBps !== s.worstUndercountBps + s.extraReserveBps
+        || s.candidateMarginBps > s.maximumMarginBps || record.qualification?.worstUndercountBps !== s.worstUndercountBps
+        || record.review?.approved !== true || !nonblank(record.review.reviewer) || record.review.selectedMarginBps !== s.candidateMarginBps
+        || record.review.qualifiedProfile?.id !== profile?.id || record.review.qualifiedProfile?.version !== profile?.version
+        || profile.safetyMarginBps !== s.candidateMarginBps || record.profileDigest !== contextLiveDigest(profile)) {
+        throw new ContextPlanError('rollout-unqualified', 'qualification record does not match the enforced profile');
+    }
+    assertContextQualified(record.qualification, profile, estimator);
+}
+/**
+ * The evaluator preflights the worst-case completion envelope before dispatch (#2797): every
+ * evaluation carries every usage entry with the binding's full retry attempts, so the 24-question
+ * `many-short` case rejects with `invalid-input` before any provider work instead of exceeding
+ * the default entry limits (`property-count`) after dispatch. The canary covers that shape as a
+ * rejected-before-dispatch case with zero dispatches in both phases.
+ */
+export function validateContextCanaryApproval(approval, corpus, record) {
+    admitEntry(approval);
+    const plan = approval?.plan;
+    if (!closed(approval, ['schemaVersion', 'approved', 'reviewer', 'stagingWorkspace', 'runId', 'sourceCommit', 'exactHeadCi', 'model', 'apiRevision', 'region',
+        'secretServiceReference', 'credentialResolverDigest', 'corpusDigest', 'qualificationRecordDigest', 'canaryPlanDigest', 'plan'])
+        || !closed(plan, ['schemaVersion', 'caseIds', 'rollback', 'budget', 'perRequestBound']) || !closed(plan.budget, ['requests', 'tokens', 'usd', 'wallClockMs'])
+        || !closed(plan.perRequestBound, ['totalTokens', 'outputTokens', 'usd', 'approvalReference'])
+        || approval.schemaVersion !== 'context-canary-approval/v1' || approval.approved !== true || plan.schemaVersion !== 'context-canary-plan/v1' || plan.rollback !== 'observe-only'
+        || ![approval.reviewer, approval.stagingWorkspace, approval.exactHeadCi, approval.model, approval.region, approval.secretServiceReference, plan.perRequestBound.approvalReference].every(nonblank)
+        || !/^[a-zA-Z0-9_-]+$/.test(approval.runId) || !/^[a-f0-9]{40}$/.test(approval.sourceCommit) || approval.apiRevision !== 'v1' || /latest|unknown/i.test(approval.model)
+        || !CREDENTIAL_REF.test(approval.secretServiceReference)
+        || ![approval.credentialResolverDigest, approval.corpusDigest, approval.qualificationRecordDigest, approval.canaryPlanDigest].every(d => sha256.test(d))
+        || approval.canaryPlanDigest !== contextLiveDigest(plan) || approval.corpusDigest !== contextLiveDigest(corpus) || approval.corpusDigest !== record.corpusDigest
+        || approval.qualificationRecordDigest !== contextLiveDigest(record) || approval.model !== record.model || approval.region !== record.region
+        || !Array.isArray(plan.caseIds) || !plan.caseIds.length || new Set(plan.caseIds).size !== plan.caseIds.length
+        || plan.caseIds.some(id => !corpus.cases.some(c => c.id === id))
+        || plan.budget.usd > TV12_ISSUE_USD_CAP
+        || [plan.budget.requests, plan.budget.tokens, plan.budget.wallClockMs, plan.perRequestBound.totalTokens, plan.perRequestBound.outputTokens].some(n => !Number.isSafeInteger(n) || n < 1)
+        || plan.perRequestBound.outputTokens > plan.perRequestBound.totalTokens
+        || [plan.budget.usd, plan.perRequestBound.usd].some(n => !Number.isFinite(n) || n <= 0 || n > Number.MAX_SAFE_INTEGER / 1_000_000)) {
+        throw new Error('Incomplete or mismatched TV-12 canary approval');
+    }
+    verifyContextQualificationRecord(record);
+}
+/** Dispatches each phase would need, derived from the qualified plan; rejected phases need none. */
+export async function contextCanaryDispatches(caseIds, corpus, record) {
+    const rows = [];
+    const adapterVersion = new JevDecisionAdapter({ region: record.region }).version;
+    for (const id of caseIds) {
+        const item = corpus.cases.find(c => c.id === id);
+        const { input } = await compileContextLiveCase(item, record.model, record.region);
+        const aliases = item.definitions.map((_, index) => `q${index}`);
+        // Mirror of the dispatch binding the canary builds per phase (single target without retries,
+        // one attempt budget per alias); the probe reads only retry ceilings and identity, never
+        // credentials, so no credential reference is carried here.
+        const envelopeBinding = { spec: { maxAttempts: aliases.length,
+                evaluations: Object.fromEntries(aliases.map(alias => [alias, { targets: [{ adapter: 'jev', adapterVersion,
+                                model: record.model, retry: { maxRetries: 0, initialDelayMs: 0, maxDelayMs: 0 } }] }])) } };
+        const envelopeItems = aliases.map((alias, index) => ({ alias, definition: item.definitions[index] }));
+        let enforce = 0, rollback = 0;
+        let enforceRejection = null;
+        let rollbackRejection = null;
+        try {
+            const planned = planDecisionContext(input, record.profile, estimator);
+            // Both phases evaluate every alias in one invocation, so both check the same worst-case
+            // envelope (#2797) — each phase with its own call. The worst-case single-dispatch shape
+            // bounds the native enforce batches as well as the single rollback dispatches, so a
+            // rejected envelope needs no dispatch in that phase.
+            for (const phase of ['enforce', 'rollback']) {
+                if (!contextResultEnvelopeFits(planned, envelopeItems, envelopeBinding)) {
+                    if (phase === 'enforce')
+                        enforceRejection = 'invalid-input';
+                    else
+                        rollbackRejection = 'invalid-input';
+                }
+                else if (phase === 'enforce')
+                    enforce = planned.partitions.length;
+                else
+                    rollback = input.questions.length;
+            }
+        }
+        catch (error) {
+            if (!(error instanceof ContextPlanError && ['oversized-state', 'oversized-question'].includes(error.reason)))
+                throw error;
+            enforceRejection = error.reason;
+            rollbackRejection = error.reason;
+        }
+        rows.push({ caseId: id, enforce, rollback, enforceRejection, rollbackRejection });
+    }
+    return rows;
+}
+function inspect(caseId, phase, expected, expectedRejection, result, aliases, model, bound, outputBound) {
+    const plan = result.spec.context?.plan ?? null;
+    const usage = result.spec.context?.actualUsage ?? [];
+    const evaluations = Object.values(result.spec.evaluations ?? {});
+    const attempts = evaluations.flatMap(e => e.spec.attempts ?? []);
+    const partitions = usage.map(u => {
+        const partition = plan?.partitions.find(p => p.id === u.partitionId);
+        const withinEffectiveLimits = !!plan && !!partition && u.questionIds.every(id => partition.questionIds.includes(id))
+            && partition.estimate.aggregateTokens <= plan.limits.effectiveAggregateTokens
+            && partition.estimate.stateAndLongestQuestionTokens <= plan.limits.effectiveStateAndLongestQuestionTokens;
+        const withinDocumentedLimits = !!plan && Number.isSafeInteger(u.actualInputTokens) && u.actualInputTokens <= plan.limits.documentedAggregateTokens && u.actualInputTokens <= bound;
+        return { partitionId: u.partitionId, questions: u.questionIds.length, estimatedInputTokens: u.estimatedInputTokens, actualInputTokens: u.actualInputTokens, withinEffectiveLimits, withinDocumentedLimits };
+    });
+    const oversizedDispatches = partitions.filter(p => !p.withinEffectiveLimits || !p.withinDocumentedLimits).length;
+    const nativeDispatches = new Set(attempts.filter(a => a.batch?.mode === 'native').map(a => a.batch.groupId)).size;
+    const requestIds = [...new Set(attempts.map(a => a.requestId).filter((id) => typeof id === 'string'))].sort();
+    const rejected = expected === 0;
+    // The provider is the only source of per-call output; null means unknown, so it fails closed.
+    // A native batch keeps one shared usage copy per request on the ruleset result while its answer
+    // attempts carry null usage by design, so requests are read there and singles from success attempts.
+    const outputReports = new Map();
+    for (const entry of result.spec.batchRequests ?? []) {
+        const key = typeof entry.requestId === 'string' && entry.requestId ? `id:${entry.requestId}` : `batch:${entry.groupId}:${entry.ordinal}`;
+        if (!outputReports.has(key))
+            outputReports.set(key, entry.usage?.outputTokens ?? null);
+    }
+    attempts.forEach((attempt, index) => {
+        if (attempt.batch?.mode === 'native' || attempt.status !== 'success')
+            return;
+        const key = typeof attempt.requestId === 'string' && attempt.requestId ? `id:${attempt.requestId}` : `single:${index}`;
+        if (!outputReports.has(key))
+            outputReports.set(key, attempt.usage?.outputTokens ?? null);
+    });
+    const outputOversizedDispatches = rejected ? 0
+        : [...outputReports.values()].filter(n => !Number.isSafeInteger(n) || n < 0 || n > outputBound).length;
+    const covered = new Set(usage.flatMap(u => u.questionIds));
+    const pass = rejected
+        ? expectedRejection !== null && usage.length === 0 && attempts.length === 0 && result.spec.contextFailure?.reason === expectedRejection
+        : oversizedDispatches === 0 && outputOversizedDispatches === 0 && usage.length === expected && covered.size === aliases.length
+            && aliases.every(alias => covered.has(decisionBatchQuestionId(alias))) && evaluations.length === aliases.length
+            && evaluations.every(e => e.spec.status === 'success') && attempts.every(a => a.status === 'success' && a.actualModel === model)
+            && (phase === 'rollback' ? nativeDispatches === 0 && usage.every(u => u.questionIds.length === 1) : true);
+    return { caseId, phase, expectedDispatches: expected, dispatches: usage.length, rejectedBeforeDispatch: rejected && usage.length === 0,
+        planDigest: plan?.planDigest ?? null, profileDigest: plan?.providerProfile.digest ?? null, requestIds, partitions, oversizedDispatches, nativeDispatches, pass, outputOversizedDispatches };
+}
+/**
+ * Enforce-mode canary. Each case runs once with the recorded qualification (native batching split by the
+ * qualified plan), then once rolled back to `observe-only`, which evaluates every question singly. All
+ * dispatches of a phase are reserved against the approved bound before it starts; the first failure stops.
+ */
+export async function runContextEnforceCanary(options) {
+    const { sourceRoot, artifactRoot, host, offlineTransport } = options;
+    const approval = structuredClone(options.approval), corpus = structuredClone(options.corpus), record = structuredClone(options.record);
+    validateContextCanaryApproval(approval, corpus, record);
+    await assertContextLiveSource(sourceRoot, approval.sourceCommit);
+    await assertContextArtifactRoot(sourceRoot, artifactRoot);
+    try {
+        return await withContextLiveSpendLedger(artifactRoot, approval.plan.budget.usd, (runsRoot, issueSpend) => canaryWithinLedger(approval, corpus, record, sourceRoot, runsRoot, issueSpend, host, offlineTransport));
+    }
+    finally {
+        host.dispose?.();
+    }
+}
+async function canaryWithinLedger(approval, corpus, record, sourceRoot, runsRoot, issueSpend, host, offlineTransport) {
+    const directory = resolve(runsRoot, approval.runId);
+    await mkdir(directory, { recursive: false, mode: 0o700 });
+    await writeFile(join(directory, 'canary-approval.json'), canonicalJson(approval), { flag: 'wx', mode: 0o600 });
+    await writeFile(join(directory, 'qualification-record.json'), canonicalJson(record), { flag: 'wx', mode: 0o600 });
+    const { plan } = approval;
+    const started = Date.now();
+    const budget = new ContextLiveBudget({ ...plan, budget: { ...plan.budget, usd: issueSpend.runUsdCeiling } }, started);
+    const controller = new AbortController();
+    const deadlineTimer = setTimeout(() => controller.abort(), Math.min(2_147_483_647, Math.floor(plan.budget.wallClockMs * 0.8)));
+    const results = [];
+    let stopped = null;
+    try {
+        for (const { caseId, enforce, rollback, enforceRejection, rollbackRejection } of await contextCanaryDispatches(plan.caseIds, corpus, record)) {
+            const item = corpus.cases.find(c => c.id === caseId);
+            for (const [phase, expected, expectedRejection] of [['enforce', enforce, enforceRejection], ['rollback', rollback, rollbackRejection]]) {
+                try {
+                    for (let i = 0; i < expected; i++)
+                        budget.reserve();
+                }
+                catch {
+                    stopped = 'budget-exhausted';
+                    break;
+                }
+                const { input, policy } = await compileContextLiveCase(item, approval.model, approval.region);
+                const aliases = item.definitions.map((_, i) => `q${i}`);
+                const definitions = Object.fromEntries(aliases.map((alias, i) => [alias, item.definitions[i]]));
+                const adapter = new JevDecisionAdapter({ region: approval.region, ...(offlineTransport ? { fetch: offlineTransport } : {}) });
+                const remaining = Math.floor(plan.budget.wallClockMs * 0.8 - (Date.now() - started));
+                if (remaining < 1 || controller.signal.aborted) {
+                    stopped = 'deadline';
+                    break;
+                }
+                const target = contextLiveTarget(approval, adapter.version, Math.min(30_000, remaining));
+                const ruleset = contextLiveRuleset(`canary-${item.id}`, aliases, item.definitions);
+                const binding = contextLiveBinding(ruleset, aliases, target, Math.min(remaining, 30_000 * aliases.length));
+                let result;
+                try {
+                    result = await evaluateDecisionRuleset({ ruleset, binding, definitions, input: item.input, runId: approval.runId,
+                        invocationId: `${approval.runId}:${item.id}:${phase}`, adapters: { jev: adapter }, signal: controller.signal,
+                        resolveCredential: async (reference) => {
+                            if (reference !== approval.secretServiceReference)
+                                throw new Error('TV-12 credential access denied');
+                            return host.resolveCredential(reference);
+                        },
+                        projection: { resolve: () => structuredClone(policy) },
+                        batching: { enabled: true, evaluations: Object.fromEntries(aliases.map(alias => [alias, { decisionSubject: subject, independent: true,
+                                    egressPolicy: contextLiveDigest(policy), hostPolicy: 'tv12-canary-v1' }])) },
+                        context: { input: { ...input, questions: input.questions.map(q => ({ ...q, id: decisionBatchQuestionId(q.id) })) }, profile: record.profile, estimator,
+                            rollout: phase === 'enforce' ? { mode: 'enforce', qualification: record.qualification } : { mode: 'observe-only' } } });
+                }
+                catch {
+                    stopped = 'evaluation-error';
+                    break;
+                }
+                const row = inspect(item.id, phase, expected, expectedRejection, result, aliases, approval.model, plan.perRequestBound.totalTokens, plan.perRequestBound.outputTokens);
+                results.push(row);
+                await writeFile(join(directory, `${item.id}-${phase}.json`), canonicalJson(row), { flag: 'wx', mode: 0o600 });
+                if (!row.pass) {
+                    stopped = 'canary-check-failed';
+                    break;
+                }
+            }
+            if (stopped)
+                break;
+        }
+    }
+    finally {
+        clearTimeout(deadlineTimer);
+    }
+    const complete = !stopped && results.length === plan.caseIds.length * 2;
+    const summary = { schemaVersion: 'context-enforce-canary/v1', source: offlineTransport ? 'synthetic' : 'provider', runId: approval.runId,
+        sourceCommit: approval.sourceCommit, qualificationRecordDigest: approval.qualificationRecordDigest, canaryPlanDigest: approval.canaryPlanDigest,
+        profile: { id: record.profile.id, version: record.profile.version, digest: record.profileDigest },
+        canaryPassed: complete && results.every(r => r.pass), stopped,
+        oversizedDispatches: results.reduce((n, r) => n + r.oversizedDispatches, 0),
+        outputOversizedDispatches: results.reduce((n, r) => n + r.outputOversizedDispatches, 0),
+        enforceDispatches: results.filter(r => r.phase === 'enforce').reduce((n, r) => n + r.dispatches, 0),
+        rollbackExercised: complete && results.filter(r => r.phase === 'rollback').every(r => r.pass),
+        rollbackNativeDispatches: results.filter(r => r.phase === 'rollback').reduce((n, r) => n + r.nativeDispatches, 0),
+        cases: results.length, reserved: { requests: budget.requests, tokens: budget.tokens, usd: budget.usd }, issueSpend,
+        requestCapacityAtStop: contextLiveRequestCapacity({ ...plan, budget: { ...plan.budget, usd: issueSpend.runUsdCeiling } }), elapsedMs: Date.now() - started };
+    await writeFile(join(directory, 'summary.json'), canonicalJson(summary), { flag: 'wx', mode: 0o600 });
+    await assertContextLiveSource(sourceRoot, approval.sourceCommit);
+    return summary;
+}
+//# sourceMappingURL=context-live-promotion.js.map