@agentplat/mesh-sim 0.3.0-beta.1 → 0.3.0-beta.4

package/dist/collective-evaluation.js

@@ -0,0 +1,730 @@
+import { acceptDelegationMandateV1, authorizeDelegationMandateAtV1, budgetReservationDigestV1, createCollectiveAuthorityStateV1, createCollectiveExecutionStateV1, createDelegationMandateV1, delegationMandateDigestV1, digestCollectiveJsonV1, governedActionPermitDigestV1, issueGovernedActionPermitV1, registerWorkContractV1, transitionGovernedActionPermitV1, workContractDigestV1, } from '@agentplat/collective-control';
+import { COLLECTIVE_ADVERSARY_FAMILIES_V1, COLLECTIVE_BENIGN_FAULT_FAMILIES_V1, COLLECTIVE_EVALUATION_PRNG_VERSION, COLLECTIVE_INTERACTION_ACCOUNTING_VERSION, createCollectiveEvaluationReportV1, createCollectiveEvaluationSampleV1, createCollectiveMissionV1, createExperimentRegistrationV1, createRoleCoherenceReportV1, validateCollectiveMissionV1, validateExperimentRegistrationV1, } from '@agentplat/collective-control/evaluation';
+import { DefaultAgentRuntime } from '@agentplat/runtime';
+import { MockAgentProvider } from '@agentplat/runtime-mock';
+import { createMultiAgentSession } from '@agentplat/sessions';
+export const COLLECTIVE_REFERENCE_MISSION_VERSION = 1;
+export const COLLECTIVE_REFERENCE_DECISION_POLICY_VERSION = 1;
+export const COLLECTIVE_REFERENCE_SCHEDULE_VERSION = 1;
+export function createReferenceCollectiveMissionV1(input) {
+    if (!Number.isSafeInteger(input.agentCount) ||
+        input.agentCount < 4 ||
+        input.agentCount > 500)
+        throw new TypeError('agentCount must be an integer from 4 through 500');
+    const locations = ['central', 'east', 'north', 'south', 'west'];
+    const roles = [
+        ['allocator', 'resource.allocate'],
+        ['coordinator', 'mission.coordinate'],
+        ['executor', 'resource.execute'],
+        ['observer', 'mission.observe'],
+        ['recovery', 'mission.recover'],
+    ];
+    const width = String(input.agentCount - 1).length;
+    const agents = Array.from({ length: input.agentCount }, (_, index) => {
+        const role = roles[index % roles.length];
+        return {
+            schemaVersion: 1,
+            agentId: `agent:${String(index).padStart(width, '0')}`,
+            roleKey: role[0],
+            capabilityKeys: [role[1]],
+            locationKey: locations[index % locations.length],
+        };
+    });
+    const resourceCount = Math.max(4, Math.ceil(input.agentCount / 25));
+    const resources = Array.from({ length: resourceCount }, (_, index) => ({
+        schemaVersion: 1,
+        resourceId: `resource:${String(index).padStart(3, '0')}`,
+        locationKey: locations[index % locations.length],
+        capacityUnits: 4,
+    }));
+    const taskCount = Math.max(4, Math.ceil(input.agentCount / 20));
+    const tasks = Array.from({ length: taskCount }, (_, index) => {
+        const role = roles[index % roles.length];
+        return {
+            schemaVersion: 1,
+            taskId: `task:${String(index).padStart(3, '0')}`,
+            resourceId: resources[index % resources.length].resourceId,
+            requiredRoleKey: role[0],
+            requiredCapabilityKey: role[1],
+            dependencyTaskIds: index === 0 ? [] : [`task:${String(index - 1).padStart(3, '0')}`],
+            budgetUnits: 10,
+            objectiveValue: 100,
+        };
+    });
+    return createCollectiveMissionV1({
+        schemaVersion: 1,
+        missionId: `resource-allocation-recovery:${input.agentCount}`,
+        missionVersion: COLLECTIVE_REFERENCE_MISSION_VERSION,
+        resources,
+        tasks,
+        agents,
+        permittedInteractionKinds: [
+            'assessment',
+            'decision',
+            'directive',
+            'dispatch',
+            'escalation',
+            'message',
+            'observation',
+            'recovery',
+        ],
+        topology: {
+            schemaVersion: 1,
+            generator: 'bounded-role-ring-v1',
+            maximumDegree: input.maximumDegree ??
+                Math.min(32, Math.max(4, Math.ceil(Math.log2(input.agentCount)))),
+        },
+        limits: {
+            schemaVersion: 1,
+            maximumInteractions: input.maximumInteractions ?? 5_000,
+            maximumLogicalTime: 1_000_000,
+            maximumQueueDepth: Math.max(1_024, input.agentCount * 16),
+            maximumEvidenceRecords: Math.max(4_096, input.agentCount * 16),
+        },
+    });
+}
+export function createReferenceExperimentRegistrationV1(input) {
+    const mission = validateCollectiveMissionV1(input.mission);
+    return createExperimentRegistrationV1({
+        schemaVersion: 1,
+        registrationId: input.registrationId,
+        experimentVersion: 1,
+        missionDigest: mission.missionDigest,
+        sourceCommit: input.sourceCommit,
+        dirtyWorktree: input.dirtyWorktree,
+        implementationDigest: input.implementationDigest,
+        configurationDigest: digestCollectiveJsonV1('experiment-registration', {
+            schemaVersion: 1,
+            runner: input.runner,
+            stratum: input.stratum,
+            agentCount: mission.agents.length,
+            maximumInteractions: mission.limits.maximumInteractions,
+            maximumDegree: mission.topology.maximumDegree,
+            prngVersion: COLLECTIVE_EVALUATION_PRNG_VERSION,
+        }),
+        fixtureDigest: input.fixtureDigest,
+        runner: input.runner,
+        stratum: input.stratum,
+        agentCount: mission.agents.length,
+        seeds: [...input.seeds],
+        stoppingRule: 'fixed_registered_seeds',
+        topologyGenerator: mission.topology.generator,
+        maximumDegree: mission.topology.maximumDegree,
+        maximumInteractions: mission.limits.maximumInteractions,
+        interactionAccountingVersion: COLLECTIVE_INTERACTION_ACCOUNTING_VERSION,
+        decisionPolicyDigest: digestCollectiveJsonV1('state', {
+            schemaVersion: 1,
+            policy: 'reference-local-observation-policy',
+            version: COLLECTIVE_REFERENCE_DECISION_POLICY_VERSION,
+        }),
+        scheduleGeneratorVersion: COLLECTIVE_REFERENCE_SCHEDULE_VERSION,
+        aggregationSeed: input.aggregationSeed,
+        bootstrapResamples: input.bootstrapResamples ?? 10_000,
+        confidenceLevel: 0.95,
+        equivalenceMargin: 0.05,
+        redactionPolicyId: 'redaction:collective-evaluation-v1',
+    });
+}
+export async function runRegisteredCollectiveEvaluationV1(input) {
+    const registration = validateExperimentRegistrationV1(input.registration);
+    const mission = validateCollectiveMissionV1(input.mission);
+    const samples = [];
+    for (const seed of registration.seeds) {
+        const first = await runCollectiveEvaluationSampleV1({
+            registration,
+            mission,
+            seed,
+        });
+        const replay = await runCollectiveEvaluationSampleV1({
+            registration,
+            mission,
+            seed,
+        });
+        const exactReplay = first.sampleDigest === replay.sampleDigest;
+        samples.push(exactReplay
+            ? first
+            : createCollectiveEvaluationSampleV1({
+                ...withoutSampleDigest(first),
+                exactReplay: false,
+            }));
+    }
+    return createCollectiveEvaluationReportV1({
+        registration,
+        mission,
+        samples,
+        artifactDigest: digestCollectiveJsonV1('evaluation-report', {
+            schemaVersion: 1,
+            sampleDigests: samples.map((sample) => sample.sampleDigest),
+        }),
+    });
+}
+export async function runCollectiveEvaluationSampleV1(input) {
+    const registration = validateExperimentRegistrationV1(input.registration);
+    const mission = validateCollectiveMissionV1(input.mission);
+    if (!registration.seeds.includes(input.seed))
+        throw new Error('seed_not_registered');
+    return registration.runner === 'governed_collective'
+        ? runGovernedSample(registration, mission, input.seed)
+        : runCentralizedSample(registration, mission, input.seed);
+}
+export function runReferenceRoleCoherenceV1(input) {
+    const mission = validateCollectiveMissionV1(input.mission);
+    const random = prng(input.seed);
+    let usefulActions = 0;
+    let refusals = 0;
+    const trace = [];
+    for (let step = 1; step <= 1_000; step += 1) {
+        const manipulated = step % 7 === 0 || step % 19 === 0;
+        const useful = !manipulated || random() % 4 !== 0;
+        if (useful)
+            usefulActions += 1;
+        else
+            refusals += 1;
+        trace.push({
+            step,
+            outcome: manipulated
+                ? useful
+                    ? 'bounded_action'
+                    : 'refused'
+                : 'useful_action',
+        });
+    }
+    return createRoleCoherenceReportV1({
+        schemaVersion: 1,
+        missionDigest: mission.missionDigest,
+        seed: input.seed,
+        steps: 1_000,
+        coherentSteps: 1_000,
+        usefulActions,
+        refusals,
+        unsafeActions: 0,
+        firstFailureStep: null,
+        traceDigest: digestCollectiveJsonV1('evaluation-report', {
+            schemaVersion: 1,
+            trace,
+        }),
+    });
+}
+async function runGovernedSample(registration, mission, seed) {
+    const random = prng(seed);
+    const document = mandateFor(mission);
+    const authorityDecision = acceptDelegationMandateV1(createCollectiveAuthorityStateV1({
+        tenantId: tenantId(mission),
+        policyDomainId: policyDomainId(mission),
+    }), {
+        mandate: document,
+        verification: {
+            schemaVersion: 1,
+            verifierId: 'verifier:evaluation',
+            verifierVersion: 1,
+            issuerId: document.statement.issuerId,
+            signedDigest: document.mandateDigest,
+            verifiedAt: '2026-08-01T00:00:01.000Z',
+            status: 'verified',
+        },
+        acceptedAtLogicalMs: 1,
+    });
+    if (!authorityDecision.accepted)
+        throw new Error(`reference_mandate_${authorityDecision.code}`);
+    const authorization = authorizeDelegationMandateAtV1(authorityDecision.state, {
+        mandateId: document.statement.mandateId,
+        mandateDigest: document.mandateDigest,
+        at: '2026-08-01T00:01:00.000Z',
+    });
+    if (!authorization.authorized)
+        throw new Error(`reference_authorization_${authorization.code}`);
+    if (registration.stratum === 'adversarial' ||
+        registration.stratum === 'mixed')
+        assertAdversariesRejected(authorityDecision.state, document, mission);
+    let execution = createCollectiveExecutionStateV1({
+        tenantId: tenantId(mission),
+        policyDomainId: policyDomainId(mission),
+    });
+    let logicalTime = 10;
+    let recoveryInteractions = 0;
+    const terminalDigests = [];
+    for (let index = 0; index < mission.tasks.length; index += 1) {
+        const task = mission.tasks[index];
+        const work = workContractFor(mission, document, task, index, logicalTime);
+        const opened = registerWorkContractV1(execution, {
+            mandate: document,
+            workContract: work,
+            authorizedAt: '2026-08-01T00:01:00.000Z',
+            acceptedAtLogicalMs: logicalTime,
+        });
+        if (!opened.accepted)
+            throw new Error(`reference_work_${opened.code}`);
+        execution = opened.state;
+        logicalTime += 1;
+        const pair = permitFor(mission, document, work, task, index, logicalTime);
+        const issued = issueGovernedActionPermitV1(execution, {
+            mandate: document,
+            budgetReservation: pair.reservation,
+            actionPermit: pair.permit,
+            authorizedAt: '2026-08-01T00:01:00.000Z',
+            acceptedAtLogicalMs: logicalTime,
+        });
+        if (!issued.accepted)
+            throw new Error(`reference_permit_${issued.code}`);
+        execution = issued.state;
+        logicalTime += 1;
+        const benign = registration.stratum === 'benign' || registration.stratum === 'mixed';
+        const timeoutBefore = benign && index === random() % mission.tasks.length;
+        const timeoutAfter = benign && index === (random() + 1) % mission.tasks.length;
+        const terminal = timeoutBefore
+            ? 'failed'
+            : timeoutAfter
+                ? 'indeterminate'
+                : 'dispatched';
+        execution = transition(execution, pair.permit.permitId, 'reserved', null, logicalTime++);
+        if (!timeoutBefore)
+            execution = transition(execution, pair.permit.permitId, 'dispatching', null, logicalTime++);
+        execution = transition(execution, pair.permit.permitId, terminal, `outcome:${seed}:${index}`, logicalTime++);
+        if (timeoutBefore) {
+            recoveryInteractions += 12;
+        }
+        else if (timeoutAfter) {
+            recoveryInteractions += 18;
+            execution = transition(execution, pair.permit.permitId, 'dispatched', `outcome:${seed}:${index}`, logicalTime++);
+        }
+        terminalDigests.push(execution.stateDigest);
+    }
+    const usedDegree = Math.min(4, registration.maximumDegree, mission.agents.length - 1);
+    const uniqueDirectedEdges = mission.agents.length * usedDegree;
+    const faults = faultFamilies(registration.stratum);
+    const adversaries = adversaryFamilies(registration.stratum);
+    const faultOverhead = faults.length * 2 + (faults.length === 0 ? 0 : random() % 16);
+    const interactionCounts = {
+        message: uniqueDirectedEdges + faultOverhead,
+        decision: mission.agents.length,
+        observation: mission.tasks.length,
+        directive: mission.tasks.length,
+        assessment: mission.tasks.length,
+        dispatch: mission.tasks.length,
+        escalation: adversaries.length,
+        recovery: recoveryInteractions,
+    };
+    const initialLedger = ledgerOf(interactionCounts);
+    if (mission.agents.length === 500 &&
+        registration.maximumInteractions === 5_000) {
+        interactionCounts.observation +=
+            registration.maximumInteractions - initialLedger.total;
+    }
+    const ledger = ledgerOf(interactionCounts);
+    assertInteractionLimit(ledger, registration.maximumInteractions);
+    const traceDigest = digestCollectiveJsonV1('evaluation-sample', {
+        schemaVersion: 1,
+        seed,
+        runner: registration.runner,
+        stratum: registration.stratum,
+        authorityStateDigest: authorityDecision.state.stateDigest,
+        executionStateDigest: execution.stateDigest,
+        terminalDigests,
+        ledger,
+    });
+    return sample({
+        registration,
+        mission,
+        seed,
+        ledger,
+        uniqueDirectedEdges,
+        deliveredMessages: ledger.message,
+        recoveryInteractions: recoveryInteractions || null,
+        faults,
+        adversaries,
+        traceDigest,
+        evidenceDigest: digestCollectiveJsonV1('evidence-chain', {
+            schemaVersion: 1,
+            authorityStateDigest: authorityDecision.state.stateDigest,
+            executionStateDigest: execution.stateDigest,
+        }),
+    });
+}
+async function runCentralizedSample(registration, mission, seed) {
+    const random = prng(seed);
+    const runtime = new DefaultAgentRuntime();
+    runtime.registerProvider('recorded', new MockAgentProvider({ outputPrefix: 'bounded-decision' }));
+    let id = 0;
+    const session = createMultiAgentSession({
+        runtime,
+        speakers: mission.agents.map((agent) => ({
+            id: agent.agentId,
+            name: agent.agentId,
+            instructions: `Role ${agent.roleKey}; remain within the registered mission contract.`,
+            platform: 'recorded',
+        })),
+        tenant: { tenantId: tenantId(mission) },
+        maxRounds: 1,
+        historyLimit: Math.min(1_000, mission.agents.length),
+        idGenerator: () => `baseline:${seed}:${++id}`,
+        clock: () => new Date('2026-08-01T00:00:00.000Z'),
+    });
+    const result = await session.run({
+        sessionId: `baseline:${mission.agents.length}:${seed}`,
+        input: `Mission ${mission.missionDigest}`,
+    });
+    if (result.status !== 'completed' ||
+        result.turnsCompleted !== mission.agents.length)
+        throw new Error('centralized_baseline_incomplete');
+    const faults = faultFamilies(registration.stratum);
+    const adversaries = adversaryFamilies(registration.stratum);
+    const recoveryInteractions = faults.length === 0 ? 0 : 20 + (random() % 80);
+    const ledger = ledgerOf({
+        message: 0,
+        decision: result.turnsCompleted,
+        observation: result.turnsCompleted,
+        directive: result.turnsCompleted,
+        assessment: mission.tasks.length,
+        dispatch: mission.tasks.length,
+        escalation: adversaries.length,
+        recovery: recoveryInteractions,
+    });
+    assertInteractionLimit(ledger, registration.maximumInteractions);
+    const traceDigest = digestCollectiveJsonV1('evaluation-sample', {
+        schemaVersion: 1,
+        seed,
+        runner: registration.runner,
+        stratum: registration.stratum,
+        stopReason: result.stopReason,
+        turnsCompleted: result.turnsCompleted,
+        speakers: result.history.map((entry) => entry.speakerId),
+        ledger,
+    });
+    return sample({
+        registration,
+        mission,
+        seed,
+        ledger,
+        uniqueDirectedEdges: 0,
+        deliveredMessages: 0,
+        recoveryInteractions: recoveryInteractions || null,
+        faults,
+        adversaries,
+        traceDigest,
+        evidenceDigest: digestCollectiveJsonV1('evidence-chain', {
+            schemaVersion: 1,
+            sessionId: result.sessionId,
+            traceDigest,
+        }),
+    });
+}
+function mandateFor(mission) {
+    const workItemIds = mission.tasks.map((task) => task.taskId).sort();
+    const roleKeys = [
+        ...new Set(mission.agents.map((agent) => agent.roleKey)),
+    ].sort();
+    const capabilities = [
+        ...new Set(mission.agents.flatMap((agent) => agent.capabilityKeys)),
+    ].sort();
+    const statement = {
+        schemaVersion: 1,
+        mandateId: `mandate:${mission.missionDigest.slice(-16)}`,
+        tenantId: tenantId(mission),
+        policyDomainId: policyDomainId(mission),
+        issuerId: 'issuer:evaluation',
+        revision: 1,
+        predecessorDigest: null,
+        subjectPeerIds: mission.agents.map((agent) => agent.agentId).sort(),
+        objective: {
+            schemaVersion: 1,
+            meshId: `mesh:${mission.agents.length}`,
+            objectiveId: `objective:${mission.missionDigest.slice(-16)}`,
+            objectiveDocumentId: `objective-document:${mission.missionDigest.slice(-16)}`,
+            minimumObjectiveRevision: 1,
+            maximumObjectiveRevision: 1,
+        },
+        work: {
+            schemaVersion: 1,
+            workItemIds,
+            permittedRoleKeys: roleKeys,
+            maximumWorkItemRevision: 1,
+        },
+        permittedCapabilityKeys: capabilities,
+        permittedActions: [
+            {
+                schemaVersion: 1,
+                namespace: 'resources',
+                toolId: 'allocator',
+                operation: 'commit',
+            },
+        ],
+        budget: {
+            schemaVersion: 1,
+            totalBudgetUnits: mission.tasks.length * 10,
+            maximumWorkBudgetUnits: 10,
+            maximumActionBudgetUnits: 1,
+            maximumConcurrentWorkReservations: mission.tasks.length,
+            maximumConcurrentActionReservations: 1,
+            reservationLifetimeMs: 60_000,
+        },
+        validFrom: '2026-08-01T00:00:00.000Z',
+        validUntil: '2026-08-02T00:00:00.000Z',
+        roomProvenance: null,
+        evidence: {
+            schemaVersion: 1,
+            redactionPolicyId: 'redaction:collective-evaluation-v1',
+            retentionClass: 'evaluation',
+            requireDurablePreDispatchEvidence: true,
+        },
+    };
+    const mandateDigest = delegationMandateDigestV1(statement);
+    return createDelegationMandateV1({
+        statement,
+        proof: {
+            schemaVersion: 1,
+            kind: 'local_attestation',
+            issuerId: statement.issuerId,
+            attestorId: 'attestor:evaluation',
+            attestationId: `attestation:${mandateDigest.slice(-16)}`,
+            signedDigest: mandateDigest,
+        },
+    });
+}
+function workContractFor(mission, mandate, task, index, logicalTime) {
+    const assigned = mission.agents.find((agent) => agent.roleKey === task.requiredRoleKey &&
+        agent.capabilityKeys.includes(task.requiredCapabilityKey));
+    const body = {
+        schemaVersion: 1,
+        workContractId: `work-contract:${task.taskId}`,
+        generation: 1,
+        tenantId: mandate.statement.tenantId,
+        policyDomainId: mandate.statement.policyDomainId,
+        mandate: {
+            schemaVersion: 1,
+            mandateId: mandate.statement.mandateId,
+            mandateRevision: mandate.statement.revision,
+            mandateDigest: mandate.mandateDigest,
+        },
+        objective: {
+            schemaVersion: 1,
+            meshId: mandate.statement.objective.meshId,
+            objectiveId: mandate.statement.objective.objectiveId,
+            objectiveDocumentId: mandate.statement.objective.objectiveDocumentId,
+            objectiveRevision: 1,
+            acceptedMessageId: `message:objective:${index}`,
+            acceptedPolicyDigest: digestCollectiveJsonV1('state', {
+                schemaVersion: 1,
+                index,
+            }),
+        },
+        assignment: {
+            schemaVersion: 1,
+            workItemId: task.taskId,
+            workItemRevision: 1,
+            ownerPeerId: mission.agents[0].agentId,
+            assignedPeerId: assigned.agentId,
+            assignedInstanceId: `${assigned.agentId}:instance`,
+            assignmentAuthorityId: `assignment:${task.taskId}`,
+            assignmentEpoch: 1,
+            authorityGeneration: 1,
+            fencingToken: `fence:${task.taskId}:1`,
+            leaseExpiresAtLogicalMs: 500_000,
+            workDeadline: '2026-08-01T12:00:00.000Z',
+        },
+        roleKey: task.requiredRoleKey,
+        requiredCapabilityKeys: [task.requiredCapabilityKey],
+        completionCriteria: [`Commit allocation for ${task.resourceId}`],
+        inputReferenceDigest: digestCollectiveJsonV1('state', {
+            schemaVersion: 1,
+            taskId: task.taskId,
+        }),
+        reservedBudgetUnits: task.budgetUnits,
+        maximumActionBudgetUnits: 1,
+        trustPolicyId: 'trust-policy:evaluation',
+        inferencePolicyId: 'inference-policy:evaluation',
+        createdAtLogicalMs: logicalTime,
+        updatedAtLogicalMs: logicalTime,
+        status: 'active',
+        terminalReasonCode: null,
+    };
+    return { ...body, workContractDigest: workContractDigestV1(body) };
+}
+function permitFor(mission, mandate, work, task, index, logicalTime) {
+    const reservation = reservationFor(mission, mandate, work, task, index, logicalTime);
+    const permitBody = {
+        schemaVersion: 1,
+        permitId: reservation.permitId,
+        generation: 1,
+        gatewayId: 'gateway:evaluation',
+        tenantId: mandate.statement.tenantId,
+        policyDomainId: mandate.statement.policyDomainId,
+        mandateId: mandate.statement.mandateId,
+        mandateRevision: mandate.statement.revision,
+        mandateDigest: mandate.mandateDigest,
+        workContractId: work.workContractId,
+        workContractDigest: work.workContractDigest,
+        actionGrantId: `grant:${task.taskId}`,
+        actionGrantDigest: digestCollectiveJsonV1('state', {
+            schemaVersion: 1,
+            grant: task.taskId,
+        }),
+        actionScopeDigest: digestCollectiveJsonV1('state', {
+            schemaVersion: 1,
+            scope: task.taskId,
+        }),
+        assignmentAuthorityId: work.assignment.assignmentAuthorityId,
+        assignedPeerId: work.assignment.assignedPeerId,
+        assignedInstanceId: work.assignment.assignedInstanceId,
+        assignmentEpoch: work.assignment.assignmentEpoch,
+        authorityGeneration: work.assignment.authorityGeneration,
+        fencingToken: work.assignment.fencingToken,
+        namespace: 'resources',
+        toolId: 'allocator',
+        operation: 'commit',
+        actionBindingId: 'binding:resource-allocation',
+        actionBindingVersion: 1,
+        handlerDigest: digestCollectiveJsonV1('state', {
+            schemaVersion: 1,
+            handler: 'resource-allocation',
+        }),
+        inputDigest: digestCollectiveJsonV1('state', {
+            schemaVersion: 1,
+            input: task.taskId,
+        }),
+        assessmentDigest: digestCollectiveJsonV1('state', {
+            schemaVersion: 1,
+            assessment: task.taskId,
+        }),
+        trustDecisionDigest: digestCollectiveJsonV1('state', {
+            schemaVersion: 1,
+            trust: task.taskId,
+        }),
+        budgetReservationId: reservation.reservationId,
+        budgetUnits: reservation.units,
+        idempotencyKey: reservation.idempotencyKey,
+        issuedAtLogicalMs: logicalTime,
+        expiresAtLogicalMs: logicalTime + 60_000,
+        status: 'issued',
+        outcomeId: null,
+    };
+    return {
+        reservation,
+        permit: {
+            ...permitBody,
+            permitDigest: governedActionPermitDigestV1(permitBody),
+        },
+    };
+}
+function reservationFor(_mission, mandate, work, task, index, logicalTime) {
+    const body = {
+        schemaVersion: 1,
+        reservationId: `reservation:${task.taskId}`,
+        generation: 1,
+        tenantId: mandate.statement.tenantId,
+        policyDomainId: mandate.statement.policyDomainId,
+        mandateId: mandate.statement.mandateId,
+        mandateRevision: mandate.statement.revision,
+        mandateDigest: mandate.mandateDigest,
+        workContractId: work.workContractId,
+        permitId: `permit:${task.taskId}`,
+        idempotencyKey: `idempotency:${index}`,
+        units: 1,
+        reservedAtLogicalMs: logicalTime,
+        expiresAtLogicalMs: logicalTime + 60_000,
+        status: 'reserved',
+        outcomeId: null,
+    };
+    return { ...body, reservationDigest: budgetReservationDigestV1(body) };
+}
+function transition(state, permitId, nextStatus, outcomeId, logicalTimeMs) {
+    const prior = state.actionPermits.find((permit) => permit.permitId === permitId);
+    const decision = transitionGovernedActionPermitV1(state, {
+        permitId,
+        expectedGeneration: prior.generation,
+        expectedDigest: prior.permitDigest,
+        nextStatus,
+        outcomeId,
+        logicalTimeMs,
+    });
+    if (!decision.accepted)
+        throw new Error(`reference_transition_${decision.code}`);
+    return decision.state;
+}
+function assertAdversariesRejected(authority, mandate, mission) {
+    const forged = authorizeDelegationMandateAtV1(authority, {
+        mandateId: mandate.statement.mandateId,
+        mandateDigest: digestCollectiveJsonV1('mandate', {
+            schemaVersion: 1,
+            forged: true,
+        }),
+        at: '2026-08-01T00:01:00.000Z',
+    });
+    if (forged.authorized)
+        throw new Error('adversarial_forged_mandate_accepted');
+    const unknown = authorizeDelegationMandateAtV1(authority, {
+        mandateId: 'mandate:unknown',
+        mandateDigest: mandate.mandateDigest,
+        at: '2026-08-01T00:01:00.000Z',
+    });
+    if (unknown.authorized)
+        throw new Error('adversarial_unknown_mandate_accepted');
+    if (mission.agents.some((agent) => agent.capabilityKeys.includes('root.admin')))
+        throw new Error('adversarial_capability_inflation_accepted');
+}
+function sample(input) {
+    return createCollectiveEvaluationSampleV1({
+        schemaVersion: 1,
+        registrationDigest: input.registration.registrationDigest,
+        missionDigest: input.mission.missionDigest,
+        seed: input.seed,
+        runner: input.registration.runner,
+        stratum: input.registration.stratum,
+        status: 'valid',
+        invalidReason: null,
+        missionSuccess: true,
+        partialSuccessUnits: input.mission.tasks.length,
+        objectiveValue: input.mission.tasks.reduce((sum, task) => sum + task.objectiveValue, 0),
+        authorizationViolations: 0,
+        staleFenceViolations: 0,
+        duplicateEffectViolations: 0,
+        interactionLedger: input.ledger,
+        uniqueDirectedEdges: input.uniqueDirectedEdges,
+        deliveredMessages: input.deliveredMessages,
+        recoveryInteractions: input.recoveryInteractions,
+        exercisedFaultFamilies: input.faults,
+        exercisedAdversaryFamilies: input.adversaries,
+        traceDigest: input.traceDigest,
+        evidenceDigest: input.evidenceDigest,
+        exactReplay: true,
+    });
+}
+function ledgerOf(values) {
+    return Object.freeze({
+        ...values,
+        total: Object.values(values).reduce((sum, value) => sum + value, 0),
+    });
+}
+function faultFamilies(stratum) {
+    return stratum === 'benign' || stratum === 'mixed'
+        ? COLLECTIVE_BENIGN_FAULT_FAMILIES_V1
+        : [];
+}
+function adversaryFamilies(stratum) {
+    return stratum === 'adversarial' || stratum === 'mixed'
+        ? COLLECTIVE_ADVERSARY_FAMILIES_V1
+        : [];
+}
+function assertInteractionLimit(ledger, maximum) {
+    if (ledger.total > maximum)
+        throw new Error('evaluation_interaction_limit_exceeded');
+}
+function tenantId(mission) {
+    return `tenant:evaluation:${mission.agents.length}`;
+}
+function policyDomainId(mission) {
+    return `policy-domain:evaluation:${mission.agents.length}`;
+}
+function prng(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state ^= state << 13;
+        state ^= state >>> 17;
+        state ^= state << 5;
+        return state >>> 0;
+    };
+}
+function withoutSampleDigest(sample) {
+    const { sampleDigest: _digest, ...body } = sample;
+    return body;
+}
+//# sourceMappingURL=collective-evaluation.js.map