@aiwg/cli 2026.9.19 → 2026.9.21

package/dist/src/decision/batch-receipts/accounting.js

@@ -0,0 +1,75 @@
+/** Adds every dispatched attempt once, including failed, retry, and fallback consumption. */
+export function batchAccountingTotals(receipt) {
+    let input = 0;
+    let output = 0;
+    let known = 0;
+    let unknown = 0;
+    let bound = 0;
+    let hasBound = false;
+    for (const attempt of receipt.attempts) {
+        input = addKnown(input, attempt.usage.inputTokens);
+        output = addKnown(output, attempt.usage.outputTokens);
+        if (attempt.cost.kind === 'provider-authoritative' || attempt.cost.kind === 'client-derived')
+            known += attempt.cost.amountMicros;
+        else if (attempt.cost.kind === 'bounded-unknown') {
+            unknown++;
+            bound += attempt.cost.upperBoundMicros;
+            hasBound = true;
+        }
+        else
+            unknown++;
+    }
+    return { usage: { inputTokens: input, outputTokens: output },
+        cost: { knownAmountMicros: known, unknownAttemptCount: unknown,
+            conservativeUpperBoundMicros: unknown === 0 ? known : hasBound && receipt.attempts.every(a => a.cost.kind !== 'unknown') ? known + bound : null } };
+}
+/** Admission consumes receipt-level evidence only; per-answer estimates are deliberately ignored. */
+export function batchEnforcementCostMicros(receipt) {
+    const total = batchAccountingTotals(receipt).cost;
+    return total.unknownAttemptCount === 0 ? total.knownAmountMicros : total.conservativeUpperBoundMicros;
+}
+/** Exact integer arithmetic; USD 0.042/million is 42,000 micros/million. */
+export function deriveCost(usage, catalog) {
+    if (usage.inputTokens === null || usage.outputTokens === null)
+        return { kind: 'unknown' };
+    validateRate(catalog.inputMicrosPerMillionTokens);
+    validateRate(catalog.outputMicrosPerMillionTokens);
+    const numerator = BigInt(usage.inputTokens) * BigInt(catalog.inputMicrosPerMillionTokens)
+        + BigInt(usage.outputTokens) * BigInt(catalog.outputMicrosPerMillionTokens);
+    const micros = Number((numerator + 500000n) / 1000000n);
+    if (!Number.isSafeInteger(micros))
+        throw new RangeError('Derived batch cost exceeds safe integer range');
+    return { kind: 'client-derived', currency: 'USD', amountMicros: micros,
+        priceCatalogId: catalog.id, priceCatalogVersion: catalog.version, effectiveAt: catalog.effectiveAt };
+}
+/** Largest remainder makes integer allocations deterministic and exactly reconciling. */
+export function allocateEstimatedUsage(questionIds, total, weights = {}) {
+    if (!questionIds.length || new Set(questionIds).size !== questionIds.length)
+        throw new RangeError('Unique question IDs are required');
+    const normalized = questionIds.map(id => weights[id] ?? 1);
+    if (normalized.some(weight => !Number.isSafeInteger(weight) || weight <= 0))
+        throw new RangeError('Allocation weights must be positive integers');
+    const input = allocate(total.inputTokens, normalized, questionIds);
+    const output = allocate(total.outputTokens, normalized, questionIds);
+    return questionIds.map((questionId, index) => ({ questionId, kind: 'estimated',
+        algorithm: 'largest-remainder-weighted', algorithmVersion: '1',
+        inputTokens: input?.[index] ?? null, outputTokens: output?.[index] ?? null }));
+}
+function allocate(total, weights, ids) {
+    if (total === null)
+        return null;
+    if (!Number.isSafeInteger(total) || total < 0)
+        throw new RangeError('Usage must be a non-negative safe integer or null');
+    const denominator = weights.reduce((sum, value) => sum + BigInt(value), 0n);
+    const base = weights.map(weight => Number(BigInt(total) * BigInt(weight) / denominator));
+    let remaining = total - base.reduce((sum, value) => sum + value, 0);
+    const order = weights.map((weight, index) => ({ index, remainder: (BigInt(total) * BigInt(weight)) % denominator, id: ids[index] }))
+        .sort((a, b) => a.remainder === b.remainder ? a.id.localeCompare(b.id) : a.remainder > b.remainder ? -1 : 1);
+    for (let index = 0; index < remaining; index++)
+        base[order[index].index]++;
+    return base;
+}
+function addKnown(sum, value) { return sum === null || value === null ? null : sum + value; }
+function validateRate(value) { if (!Number.isSafeInteger(value) || value < 0)
+    throw new RangeError('Catalog rates must be non-negative integer micros'); }
+//# sourceMappingURL=accounting.js.map

package/dist/src/decision/batch-receipts/export.js

@@ -0,0 +1,40 @@
+import { createHash } from 'node:crypto';
+/** Raw request IDs, state, response bodies, credentials, and reasoning cannot enter this shape. */
+export function sanitizedBatchReceiptExport(receipt, requestIdHashSalt) {
+    if (requestIdHashSalt.length < 16)
+        throw new Error('A deployment-scoped request-ID hash salt of at least 16 characters is required');
+    return {
+        schemaVersion: 'decision-batch-receipt-export/v1', batchId: receipt.batchId,
+        invocationId: receipt.invocationId, runId: receipt.runId,
+        plan: { planDigest: receipt.plan.planDigest, partitionId: receipt.plan.partitionId,
+            nativeBatchGroupId: receipt.plan.nativeBatchGroupId },
+        subjectHash: receipt.subjectHash, stateHash: receipt.stateHash, questionIds: [...receipt.questionIds],
+        status: receipt.status, createdAtEpochMs: receipt.createdAtEpochMs, updatedAtEpochMs: receipt.updatedAtEpochMs,
+        terminalAtEpochMs: receipt.terminalAtEpochMs,
+        attempts: receipt.attempts.map(attempt => ({
+            ordinal: attempt.ordinal, adapterId: attempt.adapterId, adapterVersion: attempt.adapterVersion,
+            requestedModel: attempt.requestedModel, actualModel: attempt.actualModel, status: attempt.status,
+            dispatchedAtEpochMs: attempt.dispatchedAtEpochMs, completedAtEpochMs: attempt.completedAtEpochMs,
+            usage: { inputTokens: attempt.usage.inputTokens, outputTokens: attempt.usage.outputTokens },
+            cost: exportCost(attempt.cost),
+            fallbackFromAttemptOrdinal: attempt.fallbackFromAttemptOrdinal,
+            providerRequestIdHash: attempt.providerRequestId === null ? null : `sha256:${createHash('sha256').update(requestIdHashSalt).update('\0').update(attempt.providerRequestId).digest('hex')}`
+        })),
+        answerReferences: receipt.answerReferences.map(ref => ({ questionId: ref.questionId, answerId: ref.answerId,
+            resultId: ref.resultId })),
+        allocations: receipt.allocations.map(value => ({ questionId: value.questionId, kind: value.kind,
+            algorithm: value.algorithm, algorithmVersion: value.algorithmVersion,
+            inputTokens: value.inputTokens, outputTokens: value.outputTokens })),
+    };
+}
+function exportCost(cost) {
+    switch (cost.kind) {
+        case 'provider-authoritative': return { kind: cost.kind, currency: cost.currency, amountMicros: cost.amountMicros };
+        case 'client-derived': return { kind: cost.kind, currency: cost.currency, amountMicros: cost.amountMicros,
+            priceCatalogId: cost.priceCatalogId, priceCatalogVersion: cost.priceCatalogVersion, effectiveAt: cost.effectiveAt };
+        case 'bounded-unknown': return { kind: cost.kind, currency: cost.currency, upperBoundMicros: cost.upperBoundMicros,
+            boundPolicyId: cost.boundPolicyId, boundPolicyVersion: cost.boundPolicyVersion };
+        case 'unknown': return { kind: 'unknown' };
+    }
+}
+//# sourceMappingURL=export.js.map

package/dist/src/decision/batch-receipts/index.js

@@ -0,0 +1,9 @@
+export * from './types.js';
+export * from './validate.js';
+export * from './accounting.js';
+export * from './receipt.js';
+export * from './store.js';
+export * from './result-store.js';
+export * from './export.js';
+export * from './protection.js';
+//# sourceMappingURL=index.js.map

package/dist/src/decision/batch-receipts/protection.js

@@ -0,0 +1,40 @@
+import { ensurePrivateDirectory as ensureProtectedDirectory, parseCanonical as parseProtectedCanonical, publishTombstone, } from '../../storage/protected-files.js';
+import { validateDecisionLifecyclePolicy } from '../lifecycle.js';
+import { BatchReceiptValidationError } from './validate.js';
+/** Opaque by design: callers learn only that stored bytes failed verification. */
+export class BatchStoreIntegrityError extends Error {
+    constructor() { super('Batch store integrity check failed'); this.name = 'BatchStoreIntegrityError'; }
+}
+/** Erased, expired, or tombstoned durable state. Replay must neither re-dispatch nor serve it. */
+export class BatchRecordUnavailableError extends Error {
+    code = 'batch-record-unavailable';
+    constructor() { super('Batch record unavailable'); this.name = 'BatchRecordUnavailableError'; }
+}
+/** Unkeyed records from before integrity protection. They are read-only until explicitly migrated. */
+export class BatchStoreMigrationRequiredError extends Error {
+    code = 'batch-store-migration-required';
+    constructor() { super('Batch store requires explicit migration'); this.name = 'BatchStoreMigrationRequiredError'; }
+}
+// Generic protected-file primitives live in src/storage; they are re-exported
+// here so existing batch-store imports keep their names and behavior.
+export { exists, keyedName, macFor, macMatches, publishExclusive, requireIntegrityKey, serialized, syncDirectory, } from '../../storage/protected-files.js';
+export function receiptLifecycleRule(binding) {
+    validateDecisionLifecyclePolicy(binding?.lifecycle);
+    return binding.lifecycle.surfaces.receipt;
+}
+/** Stored bytes must be exactly the canonical serialization, so no byte can change unnoticed. */
+export function parseCanonical(raw) {
+    return parseProtectedCanonical(raw, () => new BatchStoreIntegrityError());
+}
+export async function ensurePrivateDirectory(directory, message) {
+    await ensureProtectedDirectory(directory, message, (text) => new BatchReceiptValidationError(text ?? message));
+}
+/** Body-free local tombstone. Its presence alone blocks reads, writes, acquisition and restore. */
+export async function writeTombstone(directory, path, reference, deletedAt) {
+    // An existing tombstone already has the same effect; erasure is idempotent.
+    await publishTombstone(directory, path, { version: 'decision-batch-tombstone/v1', reference, deletedAtEpochMs: deletedAt }, 'batch-tombstone');
+}
+export function expired(createdAtEpochMs, now, rule) {
+    return !Number.isSafeInteger(now) || now < createdAtEpochMs || now - createdAtEpochMs >= rule.retentionMs;
+}
+//# sourceMappingURL=protection.js.map

package/dist/src/decision/batch-receipts/receipt.js

@@ -0,0 +1,44 @@
+import { assertNoPortableSecretMaterial } from '../portable-secrets.js';
+import { BatchReceiptValidationError, validateBatchReceipt, validateBatchReceiptTransition } from './validate.js';
+/** Integration hook for D04 native groups and D06 deterministic context partitions. */
+export function newBatchReceipt(input) {
+    if (input.partition.subject !== input.contextPlan.subject
+        || !input.contextPlan.partitions.some(candidate => candidate.id === input.partition.id)) {
+        throw new Error('Batch partition does not belong to the supplied context plan');
+    }
+    const receipt = {
+        schemaVersion: 'decision-batch-receipt/v1', revision: 1,
+        tenantId: input.tenantId, projectId: input.projectId, batchId: input.batchId,
+        invocationId: input.invocationId, runId: input.runId,
+        plan: { planDigest: input.contextPlan.planDigest, partitionId: input.partition.id,
+            nativeBatchGroupId: input.nativeBatchGroupId ?? null },
+        subjectHash: input.subjectHash, stateHash: input.partition.stateDigest,
+        executionEnvelope: input.executionEnvelope, questionIds: [...input.partition.questionIds],
+        attempts: [], answerReferences: [], allocations: [], status: 'acquired',
+        createdAtEpochMs: input.nowEpochMs, updatedAtEpochMs: input.nowEpochMs, terminalAtEpochMs: null,
+        ...(input.traceParent !== undefined ? { traceParent: input.traceParent } : {}),
+    };
+    validateBatchReceipt(receipt);
+    assertBatchReceiptPortable(receipt);
+    return receipt;
+}
+export function nextBatchReceipt(previous, update) {
+    const terminal = update.status === 'completed' || update.status === 'failed' || update.status === 'execution-uncertain';
+    const next = { ...structuredClone(previous), ...structuredClone(update),
+        revision: previous.revision + 1, terminalAtEpochMs: terminal ? update.updatedAtEpochMs : null };
+    validateBatchReceiptTransition(previous, next);
+    assertBatchReceiptPortable(next);
+    return next;
+}
+/** Batch receipts are portable artifacts: reject embedded keys, bearer values, private locators, and secret hashes. */
+export function assertBatchReceiptPortable(receipt) {
+    assertNoPortableSecretMaterial(receipt, 'Batch receipt', message => new BatchReceiptValidationError(message));
+}
+export function batchResultReference(receipt, questionId) {
+    const answer = receipt.answerReferences.find(candidate => candidate.questionId === questionId);
+    if (!answer)
+        throw new Error(`No answer reference for question '${questionId}'`);
+    return { schemaVersion: 'decision-batch-result-ref/v1', batchId: receipt.batchId,
+        receiptRevision: receipt.revision, questionId, answerId: answer.answerId };
+}
+//# sourceMappingURL=receipt.js.map

package/dist/src/decision/batch-receipts/result-store.js

@@ -0,0 +1,341 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from 'node:crypto';
+import { lstat, readFile, readdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { canonicalJson } from '../../security/artifact-trust.js';
+import { BatchRecordUnavailableError, BatchStoreIntegrityError, BatchStoreMigrationRequiredError, ensurePrivateDirectory, exists, expired, keyedName, macFor, macMatches, parseCanonical, publishExclusive, receiptLifecycleRule, requireIntegrityKey, serialized, syncDirectory, writeTombstone } from './protection.js';
+import { BatchReceiptValidationError } from './validate.js';
+export class MemoryBatchResultStore {
+    records = new Map();
+    async writeMany(receipt, observations) {
+        const snapshots = snapshotsFor(receipt, observations);
+        for (const snapshot of snapshots) {
+            const existing = this.records.get(snapshotKey(snapshot));
+            if (existing && canonicalJson(existing) !== canonicalJson(snapshot)) {
+                throw new BatchReceiptValidationError('Conflicting batch result publication');
+            }
+        }
+        for (const snapshot of snapshots)
+            this.records.set(snapshotKey(snapshot), structuredClone(snapshot));
+    }
+    async readMany(receipt) {
+        const found = new Map();
+        for (const reference of receipt.answerReferences) {
+            const snapshot = this.records.get(snapshotKey({ ...scope(receipt), questionId: reference.questionId, answerId: reference.answerId }));
+            if (!snapshot)
+                return new Map();
+            validateSnapshotForReceipt(snapshot, receipt);
+            found.set(reference.questionId, structuredClone(snapshot.observation));
+        }
+        return found;
+    }
+}
+const ENVELOPE = 'decision-batch-result-envelope/v1';
+const MAC_DOMAIN = 'decision-batch-result/v1';
+const SEALED = /^([a-f0-9]{64})\.([a-f0-9]{64})\.sealed\.json$/;
+const LEGACY = /^([a-f0-9]{64})\.json$/;
+/**
+ * Snapshot values are encrypted with AES-256-GCM. The AAD binds tenant, project, batch, question,
+ * answer and receipt revision, so a snapshot moved to any other scope fails authentication.
+ */
+export class FileBatchResultStore {
+    directory;
+    options;
+    key;
+    rule;
+    clock;
+    constructor(directory, options) {
+        this.directory = directory;
+        this.options = options;
+        this.key = requireIntegrityKey(options?.integrityKey, 'Batch result');
+        if (typeof options.resolveEncryptionKey !== 'function' || typeof options.encryptionKeyReference !== 'string'
+            || !options.encryptionKeyReference)
+            throw new Error('Batch result encryption key resolver required');
+        this.rule = receiptLifecycleRule(options);
+        this.clock = options.clock ?? Date.now;
+    }
+    async writeMany(receipt, observations) {
+        await this.ensurePrivateDirectory();
+        const snapshots = snapshotsFor(receipt, observations);
+        if (await exists(this.tombstonePath(this.batchPrefix(receipt))))
+            throw new BatchRecordUnavailableError();
+        for (const snapshot of snapshots) {
+            if (await exists(join(this.directory, `${legacyName(snapshot)}.json`)))
+                throw new BatchStoreMigrationRequiredError();
+        }
+        for (const snapshot of snapshots)
+            await this.publish(snapshot);
+    }
+    /** Erased, expired and missing snapshots all return an empty map. A verification failure throws. */
+    async readMany(receipt) {
+        await this.ensurePrivateDirectory();
+        if (await exists(this.tombstonePath(this.batchPrefix(receipt))))
+            return new Map();
+        // Values expire with their primary receipt as well as on their own creation time.
+        if (expired(receipt.createdAtEpochMs, this.clock(), this.rule))
+            return new Map();
+        const found = new Map();
+        for (const reference of receipt.answerReferences) {
+            const identity = { ...scope(receipt), receiptRevision: receipt.revision,
+                questionId: reference.questionId, answerId: reference.answerId };
+            const envelope = await this.envelope(this.directory, this.sealedName(identity));
+            if (!envelope) {
+                if (await exists(join(this.directory, `${legacyName(identity)}.json`)))
+                    throw new BatchStoreMigrationRequiredError();
+                return new Map();
+            }
+            if (expired(envelope.createdAtEpochMs, this.clock(), this.rule))
+                return new Map();
+            const snapshot = await this.decrypt(envelope, identity);
+            validateSnapshotForReceipt(snapshot, receipt);
+            found.set(reference.questionId, structuredClone(snapshot.observation));
+        }
+        return found;
+    }
+    /** Cascade target of batch receipt erasure: a body-free tombstone, then every snapshot body is removed. */
+    async eraseBatch(batchId, tenantId, projectId) {
+        await this.ensurePrivateDirectory();
+        const prefix = this.batchPrefix({ batchId, tenantId, projectId });
+        await writeTombstone(this.directory, this.tombstonePath(prefix), { surface: 'receipt', opaqueId: `batch-result-${prefix}` }, this.clock());
+        for (const name of await readdir(this.directory)) {
+            if (SEALED.exec(name)?.[1] === prefix)
+                await rm(join(this.directory, name), { force: true });
+        }
+        await syncDirectory(this.directory);
+    }
+    /** Restore sealed snapshots from a backup copy, refusing erased batches, expired values and unverifiable files. */
+    async restoreFrom(backupDirectory) {
+        if (this.rule.backup === 'not-persisted')
+            throw new Error('Batch result backup restore denied by lifecycle policy');
+        await this.ensurePrivateDirectory();
+        const report = { restored: 0, refused: 0 };
+        for (const name of await readdir(backupDirectory)) {
+            const match = SEALED.exec(name);
+            if (!match)
+                continue;
+            try {
+                const envelope = await this.envelope(backupDirectory, name);
+                if (!envelope || await exists(this.tombstonePath(match[1]))
+                    || expired(envelope.createdAtEpochMs, this.clock(), this.rule)) {
+                    report.refused++;
+                    continue;
+                }
+                const contents = serialized(envelope);
+                if (!await publishExclusive(this.directory, join(this.directory, name), contents, 'batch-result')
+                    && await readFile(join(this.directory, name), 'utf8') !== contents)
+                    throw new BatchStoreIntegrityError();
+                report.restored++;
+            }
+            catch {
+                report.refused++;
+            }
+        }
+        return report;
+    }
+    /**
+     * Explicit, authorized upgrade of plaintext snapshots written before encryption. Every legacy
+     * file is validated before authorization; each is sealed and encrypted, then the plaintext is removed.
+     */
+    async migrateLegacy(authorize) {
+        await this.ensurePrivateDirectory();
+        const legacy = [];
+        for (const name of await readdir(this.directory)) {
+            const match = LEGACY.exec(name);
+            if (!match)
+                continue;
+            const path = join(this.directory, name);
+            await assertPrivateFile(path);
+            let snapshot;
+            try {
+                snapshot = JSON.parse(await readFile(path, 'utf8'));
+                validateSnapshotShape(snapshot);
+            }
+            catch {
+                throw new BatchStoreIntegrityError();
+            }
+            if (legacyName(snapshot) !== match[1])
+                throw new BatchStoreIntegrityError();
+            legacy.push({ name, snapshot });
+        }
+        if (!legacy.length)
+            return { migrated: 0 };
+        let approved = false;
+        try {
+            approved = await authorize({ results: legacy.length }) === true;
+        }
+        catch { /* authorization fails closed */ }
+        if (!approved)
+            throw new Error('Batch store migration denied');
+        for (const { name, snapshot } of legacy) {
+            if (await exists(this.tombstonePath(this.batchPrefix(snapshot))))
+                throw new BatchRecordUnavailableError();
+            await this.publish(snapshot);
+            await rm(join(this.directory, name));
+        }
+        await syncDirectory(this.directory);
+        return { migrated: legacy.length };
+    }
+    batchPrefix(input) {
+        return keyedName(this.key, 'decision-batch-result-batch/v1', [input.tenantId, input.projectId, input.batchId]);
+    }
+    sealedName(input) {
+        return `${this.batchPrefix(input)}.${keyedName(this.key, 'decision-batch-result-answer/v1', [input.questionId, input.answerId])}.sealed.json`;
+    }
+    tombstonePath(prefix) { return join(this.directory, `${prefix}.tombstone`); }
+    async ensurePrivateDirectory() {
+        await ensurePrivateDirectory(this.directory, 'Insecure batch result directory');
+    }
+    async resolveKey(reference) {
+        let resolved;
+        try {
+            resolved = await this.options.resolveEncryptionKey(reference);
+        }
+        catch {
+            throw new Error('Batch result encryption key unavailable');
+        }
+        if (!(resolved instanceof Uint8Array) || resolved.length !== 32)
+            throw new Error('Batch result encryption key invalid');
+        return Buffer.from(resolved);
+    }
+    async publish(snapshot) {
+        const keyReference = this.options.encryptionKeyReference;
+        const nonce = randomBytes(12);
+        const key = await this.resolveKey(keyReference);
+        let ciphertext;
+        let tag;
+        try {
+            const cipher = createCipheriv('aes-256-gcm', key, nonce);
+            cipher.setAAD(aad(snapshot, keyReference, snapshot.createdAtEpochMs));
+            ciphertext = Buffer.concat([cipher.update(canonicalJson(snapshot), 'utf8'), cipher.final()]);
+            tag = cipher.getAuthTag();
+        }
+        finally {
+            key.fill(0);
+        }
+        const fields = { version: ENVELOPE, keyReference, createdAtEpochMs: snapshot.createdAtEpochMs,
+            nonce: nonce.toString('base64url'), tag: tag.toString('base64url'), ciphertext: ciphertext.toString('base64url') };
+        const envelope = { ...fields, mac: macFor(this.key, MAC_DOMAIN, fields) };
+        const name = this.sealedName(snapshot);
+        if (await publishExclusive(this.directory, join(this.directory, name), serialized(envelope), 'batch-result'))
+            return;
+        const existing = await this.envelope(this.directory, name);
+        if (!existing || canonicalJson(await this.decrypt(existing, snapshot)) !== canonicalJson(snapshot)) {
+            throw new BatchReceiptValidationError('Conflicting batch result publication');
+        }
+    }
+    async envelope(directory, name) {
+        const path = join(directory, name);
+        if (directory === this.directory) {
+            try {
+                await assertPrivateFile(path);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    return null;
+                throw error;
+            }
+        }
+        try {
+            const envelope = parseCanonical(await readFile(path, 'utf8'));
+            const { mac, ...fields } = envelope ?? {};
+            if (envelope?.version !== ENVELOPE || Object.keys(envelope).length !== 7
+                || typeof envelope.keyReference !== 'string' || !envelope.keyReference
+                || !Number.isSafeInteger(envelope.createdAtEpochMs) || envelope.createdAtEpochMs < 0
+                || ![envelope.nonce, envelope.tag, envelope.ciphertext].every(part => typeof part === 'string' && /^[A-Za-z0-9_-]+$/.test(part))
+                || !macMatches(this.key, MAC_DOMAIN, fields, mac))
+                throw new BatchStoreIntegrityError();
+            return envelope;
+        }
+        catch {
+            throw new BatchStoreIntegrityError();
+        }
+    }
+    async decrypt(envelope, identity) {
+        const key = await this.resolveKey(envelope.keyReference);
+        try {
+            const decipher = createDecipheriv('aes-256-gcm', key, Buffer.from(envelope.nonce, 'base64url'));
+            decipher.setAAD(aad(identity, envelope.keyReference, envelope.createdAtEpochMs));
+            decipher.setAuthTag(Buffer.from(envelope.tag, 'base64url'));
+            const plain = Buffer.concat([decipher.update(Buffer.from(envelope.ciphertext, 'base64url')), decipher.final()]);
+            const snapshot = JSON.parse(plain.toString('utf8'));
+            validateSnapshotShape(snapshot);
+            if (snapshot.createdAtEpochMs !== envelope.createdAtEpochMs)
+                throw new BatchStoreIntegrityError();
+            return snapshot;
+        }
+        catch {
+            throw new BatchStoreIntegrityError();
+        }
+        finally {
+            key.fill(0);
+        }
+    }
+}
+function aad(identity, keyReference, createdAtEpochMs) {
+    return Buffer.from(canonicalJson({ domain: MAC_DOMAIN, tenantId: identity.tenantId, projectId: identity.projectId,
+        batchId: identity.batchId, receiptRevision: identity.receiptRevision, questionId: identity.questionId,
+        answerId: identity.answerId, keyReference, createdAtEpochMs }), 'utf8');
+}
+async function assertPrivateFile(path) {
+    const stat = await lstat(path);
+    if (!stat.isFile() || (stat.mode & 0o077) !== 0)
+        throw new BatchReceiptValidationError('Insecure batch result file');
+}
+function snapshotsFor(receipt, observations) {
+    if (receipt.status !== 'completed' || receipt.terminalAtEpochMs === null) {
+        throw new BatchReceiptValidationError('Batch results require a completed receipt');
+    }
+    if (observations.size !== receipt.answerReferences.length) {
+        throw new BatchReceiptValidationError('Batch result set does not match receipt references');
+    }
+    return receipt.answerReferences.map(reference => {
+        const observation = observations.get(reference.questionId);
+        if (!observation || observation.status !== 'success') {
+            throw new BatchReceiptValidationError('Batch result store only accepts successful completed observations');
+        }
+        const snapshot = {
+            schemaVersion: 'decision-batch-result/v1', ...scope(receipt), receiptRevision: receipt.revision,
+            questionId: reference.questionId, answerId: reference.answerId, resultId: reference.resultId,
+            observation: structuredClone(observation), createdAtEpochMs: receipt.terminalAtEpochMs,
+        };
+        validateSnapshotForReceipt(snapshot, receipt);
+        return snapshot;
+    });
+}
+function validateSnapshotShape(snapshot) {
+    if (!snapshot || snapshot.schemaVersion !== 'decision-batch-result/v1'
+        || [snapshot.tenantId, snapshot.projectId, snapshot.batchId, snapshot.questionId, snapshot.answerId, snapshot.resultId]
+            .some(value => typeof value !== 'string' || !value)
+        || !Number.isSafeInteger(snapshot.receiptRevision) || snapshot.receiptRevision < 1
+        || !Number.isSafeInteger(snapshot.createdAtEpochMs) || snapshot.createdAtEpochMs < 0
+        || !snapshot.observation || snapshot.observation.status !== 'success') {
+        throw new BatchReceiptValidationError('Invalid batch result snapshot');
+    }
+}
+function validateSnapshotForReceipt(snapshot, receipt) {
+    if (snapshot.schemaVersion !== 'decision-batch-result/v1'
+        || snapshot.tenantId !== receipt.tenantId || snapshot.projectId !== receipt.projectId
+        || snapshot.batchId !== receipt.batchId || snapshot.receiptRevision !== receipt.revision) {
+        throw new BatchReceiptValidationError('Batch result scope substitution');
+    }
+    const reference = receipt.answerReferences.find(candidate => candidate.questionId === snapshot.questionId);
+    if (!reference || reference.answerId !== snapshot.answerId || reference.resultId !== snapshot.resultId) {
+        throw new BatchReceiptValidationError('Batch result reference mismatch');
+    }
+    if (snapshot.createdAtEpochMs !== receipt.terminalAtEpochMs || snapshot.observation.status !== 'success'
+        || snapshot.observation.requestId !== null || snapshot.observation.requestIdSource !== undefined
+        || snapshot.observation.usage?.inputTokens !== null || snapshot.observation.usage?.outputTokens !== null
+        || snapshot.observation.usage?.costUsd !== null) {
+        throw new BatchReceiptValidationError('Batch result must contain only successful value evidence, not shared accounting');
+    }
+}
+function scope(receipt) {
+    return { tenantId: receipt.tenantId, projectId: receipt.projectId, batchId: receipt.batchId };
+}
+function snapshotKey(input) {
+    return `${input.tenantId}\u0000${input.projectId}\u0000${input.batchId}\u0000${input.questionId}\u0000${input.answerId}`;
+}
+/** Unkeyed name used by stores written before encryption; only migration and refusal checks read it. */
+function legacyName(input) {
+    return createHash('sha256').update(snapshotKey(input)).digest('hex');
+}
+//# sourceMappingURL=result-store.js.map