@haystackeditor/cli 0.25.1 → 0.27.0

package/dist/commands/cloud-verifier-materialization.js

@@ -1,704 +0,0 @@
-const STABLE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-const OPERATIONAL_STATUSES = new Set([
-    'declared',
-    'adapter-verified',
-    'materialization-probed',
-]);
-const LATENCY_BASES = new Set(['assumed', 'measured']);
-const READINESS_STATUSES = new Set([
-    'proposal',
-    'cold-preparable',
-    'hot-path-proven',
-    'blocked',
-]);
-const READINESS_SCOPES = new Set(['real-production', 'synthetic-evaluation']);
-const REFRESH_STRATEGIES = new Set([
-    'scheduled',
-    'on-source-cut-change',
-    'continuous',
-    'manual',
-]);
-const HOT_PATH_PROBE_SOURCE_KINDS = new Set([
-    'haystack-materialization-probe-result',
-    'provider-materialization-probe-result',
-]);
-const GENERATED_CASE_IDENTITY_FIELDS = [
-    'generated_case_id',
-    'sandbox_id',
-    'universe_incarnation_id',
-];
-const GENERATED_CASE_PARALLEL_PHASES = ['fork', 'attach', 'execute'];
-const GENERATED_CASE_CLEANUP_ORDER = [
-    'release-all-attachments',
-    'revoke-all-leases',
-];
-export const MAX_GENERATED_CASE_FANOUT = 64;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isNonemptyString(value) {
-    return typeof value === 'string' && value.trim().length > 0;
-}
-function isNonnegativeInteger(value) {
-    return Number.isInteger(value) && Number(value) >= 0;
-}
-function isPositiveInteger(value) {
-    return Number.isInteger(value) && Number(value) > 0;
-}
-function isExactStringSequence(value, expected) {
-    return (Array.isArray(value) &&
-        value.length === expected.length &&
-        value.every((entry, index) => entry === expected[index]));
-}
-function issue(issues, path, message, file = 'universe.yml') {
-    issues.push({ file, path, message });
-}
-function mappingAt(parent, key, path, issues) {
-    const value = parent[key];
-    if (!isRecord(value)) {
-        issue(issues, path, 'must be a mapping');
-        return null;
-    }
-    return value;
-}
-function recordsAt(parent, key, path, issues, required = true) {
-    const value = parent[key];
-    if (value === undefined && !required)
-        return [];
-    if (!Array.isArray(value)) {
-        issue(issues, path, 'must be a list');
-        return [];
-    }
-    const result = [];
-    value.forEach((entry, index) => {
-        if (!isRecord(entry)) {
-            issue(issues, `${path}[${index}]`, 'must be a mapping');
-            return;
-        }
-        result.push(entry);
-    });
-    return result;
-}
-function checkId(value, path, targetIds, issues) {
-    if (typeof value !== 'string' || !STABLE_ID.test(value)) {
-        issue(issues, path, 'must be a lowercase kebab-case stable ID reference');
-        return null;
-    }
-    if (!targetIds.has(value)) {
-        issue(issues, path, `unknown stable ID reference "${value}"`);
-    }
-    return value;
-}
-function registerIds(records, path, globalIds, issues) {
-    const localIds = new Set();
-    records.forEach((record, index) => {
-        const id = record.id;
-        if (typeof id !== 'string' || !STABLE_ID.test(id)) {
-            issue(issues, `${path}[${index}].id`, 'must be a lowercase kebab-case stable ID');
-            return;
-        }
-        if (globalIds.has(id)) {
-            issue(issues, `${path}[${index}].id`, `duplicate stable ID "${id}"`);
-            return;
-        }
-        globalIds.add(id);
-        localIds.add(id);
-    });
-    return localIds;
-}
-function checkIdList(value, path, targetIds, issues, options = {}) {
-    if (!Array.isArray(value)) {
-        issue(issues, path, 'must be a list of stable ID references');
-        return [];
-    }
-    if (options.nonempty && value.length === 0) {
-        issue(issues, path, 'must be a non-empty list of stable ID references');
-    }
-    const result = [];
-    value.forEach((entry, index) => {
-        if (typeof entry !== 'string' || !STABLE_ID.test(entry)) {
-            issue(issues, `${path}[${index}]`, 'must be a lowercase kebab-case stable ID reference');
-            return;
-        }
-        result.push(entry);
-        if (!targetIds.has(entry)) {
-            issue(issues, `${path}[${index}]`, `unknown stable ID reference "${entry}"`);
-        }
-    });
-    return result;
-}
-function checkEvidenceIdList(value, path, evidenceById, issues, nonempty) {
-    return checkIdList(value, path, new Set(evidenceById.keys()), issues, { nonempty });
-}
-function requireEvidenceSubjectLinks(ids, path, subjectIds, evidenceById, issues) {
-    ids.forEach((id, index) => {
-        const record = evidenceById.get(id);
-        if (!record)
-            return;
-        subjectIds.forEach((subjectId) => {
-            if (!Array.isArray(record.subject_ids) || !record.subject_ids.includes(subjectId)) {
-                issue(issues, `${path}[${index}]`, `evidence "${id}" must name "${subjectId}" in subject_ids`);
-            }
-        });
-    });
-}
-export function validateMaterializationCapabilityMetadata(record, path, issues) {
-    if (record.claim_kind !== 'materialization-capability')
-        return;
-    if (typeof record.operational_status !== 'string' ||
-        !OPERATIONAL_STATUSES.has(record.operational_status)) {
-        issue(issues, `${path}.operational_status`, 'must be "declared", "adapter-verified", or "materialization-probed"', 'evidence.yml');
-    }
-    if (typeof record.latency_basis !== 'string' || !LATENCY_BASES.has(record.latency_basis)) {
-        issue(issues, `${path}.latency_basis`, 'must be "assumed" or "measured"', 'evidence.yml');
-    }
-}
-function validateStepCapabilityEvidence(step, path, evidenceById, issues, requiredOperationalStatus) {
-    const ids = checkEvidenceIdList(step.capability_evidence_ids, `${path}.capability_evidence_ids`, evidenceById, issues, true);
-    const requiredRank = {
-        declared: 0,
-        'adapter-verified': 1,
-        'materialization-probed': 2,
-    }[requiredOperationalStatus];
-    ids.forEach((id, index) => {
-        const evidence = evidenceById.get(id);
-        if (!evidence)
-            return;
-        const evidencePath = `${path}.capability_evidence_ids[${index}]`;
-        if (evidence.claim_kind !== 'materialization-capability') {
-            issue(issues, evidencePath, `capability evidence "${id}" must use claim_kind "materialization-capability"`);
-        }
-        if (evidence.confidence !== 'proven') {
-            issue(issues, evidencePath, `capability evidence "${id}" must have confidence "proven"`);
-        }
-        if (!Array.isArray(evidence.subject_ids) || !evidence.subject_ids.includes(step.id)) {
-            issue(issues, evidencePath, `capability evidence "${id}" must name step "${String(step.id)}" in subject_ids`);
-        }
-        const actualRank = typeof evidence.operational_status === 'string'
-            ? {
-                declared: 0,
-                'adapter-verified': 1,
-                'materialization-probed': 2,
-            }[evidence.operational_status]
-            : undefined;
-        if (actualRank === undefined || actualRank < requiredRank) {
-            issue(issues, evidencePath, `capability evidence "${id}" must have operational_status "${requiredOperationalStatus}" or stronger`);
-        }
-        if (step.latency_basis === 'measured' && evidence.latency_basis !== 'measured') {
-            issue(issues, evidencePath, `measured step latency requires capability evidence "${id}" with latency_basis "measured"`);
-        }
-    });
-}
-function computeCriticalPath(steps, stepIds, path, metric, issues) {
-    const byId = new Map();
-    steps.forEach((record, index) => {
-        if (typeof record.id === 'string' && stepIds.has(record.id)) {
-            byId.set(record.id, { record, index });
-        }
-    });
-    const state = new Map();
-    const memo = new Map();
-    let valid = true;
-    const visit = (id, trail) => {
-        const currentState = state.get(id);
-        if (currentState === 'visited')
-            return memo.get(id) ?? 0;
-        if (currentState === 'visiting') {
-            valid = false;
-            issue(issues, path, `step dependency graph contains a cycle: ${[...trail, id].join(' -> ')}`);
-            return 0;
-        }
-        const found = byId.get(id);
-        if (!found)
-            return 0;
-        state.set(id, 'visiting');
-        const dependencies = Array.isArray(found.record.depends_on_step_ids)
-            ? found.record.depends_on_step_ids.filter((entry) => typeof entry === 'string')
-            : [];
-        let dependencyMax = 0;
-        dependencies.forEach((dependencyId) => {
-            if (stepIds.has(dependencyId)) {
-                dependencyMax = Math.max(dependencyMax, visit(dependencyId, [...trail, id]));
-            }
-        });
-        const own = found.record[metric];
-        if (!isNonnegativeInteger(own)) {
-            valid = false;
-            return dependencyMax;
-        }
-        const total = dependencyMax + own;
-        memo.set(id, total);
-        state.set(id, 'visited');
-        return total;
-    };
-    let critical = 0;
-    stepIds.forEach((id) => {
-        critical = Math.max(critical, visit(id, []));
-    });
-    return valid ? critical : null;
-}
-function validatePhase(phase, phaseName, globalIds, allSubjectIds, preparedStateIds, evidenceById, issues, requiredOperationalStatus) {
-    const path = `materialization_plan.${phaseName}`;
-    const steps = recordsAt(phase, 'steps', `${path}.steps`, issues);
-    const stepIds = registerIds(steps, `${path}.steps`, globalIds, issues);
-    const knownSubjects = new Set([...allSubjectIds, ...globalIds]);
-    const producedPreparedStateIds = new Set();
-    steps.forEach((step, index) => {
-        const stepPath = `${path}.steps[${index}]`;
-        if (!isNonemptyString(step.kind))
-            issue(issues, `${stepPath}.kind`, 'must be a non-empty string');
-        checkIdList(step.subject_ids, `${stepPath}.subject_ids`, knownSubjects, issues, {
-            nonempty: true,
-        });
-        checkIdList(step.depends_on_step_ids, `${stepPath}.depends_on_step_ids`, stepIds, issues);
-        if (typeof step.latency_basis !== 'string' || !LATENCY_BASES.has(step.latency_basis)) {
-            issue(issues, `${stepPath}.latency_basis`, 'must be "assumed" or "measured"');
-        }
-        for (const metric of ['planned_typical_ms', 'planned_high_ms']) {
-            if (!isNonnegativeInteger(step[metric])) {
-                issue(issues, `${stepPath}.${metric}`, 'must be a non-negative integer number of milliseconds');
-            }
-        }
-        if (step.expected_ms !== undefined) {
-            issue(issues, `${stepPath}.expected_ms`, 'is not an honest branch-duration label; use planned_typical_ms');
-        }
-        if (step.component_p95_ms !== undefined) {
-            issue(issues, `${stepPath}.component_p95_ms`, 'cannot be summed into a phase p95; use planned_high_ms for the planning input');
-        }
-        validateStepCapabilityEvidence(step, stepPath, evidenceById, issues, requiredOperationalStatus);
-        if (phaseName === 'cold_preparation') {
-            const produced = checkIdList(step.produces_prepared_state_ids, `${stepPath}.produces_prepared_state_ids`, preparedStateIds, issues);
-            produced.forEach((id) => producedPreparedStateIds.add(id));
-        }
-    });
-    const plannedTypicalCriticalPathMs = computeCriticalPath(steps, stepIds, `${path}.steps`, 'planned_typical_ms', issues);
-    const plannedHighCriticalPathMs = computeCriticalPath(steps, stepIds, `${path}.steps`, 'planned_high_ms', issues);
-    const emptyLegacyPlanningAlias = steps.length === 0 &&
-        phase.planned_typical_critical_path_ms === undefined &&
-        phase.reported_expected_critical_path_ms === 0;
-    const plannedTypical = emptyLegacyPlanningAlias
-        ? 0
-        : phase.planned_typical_critical_path_ms;
-    if (!isNonnegativeInteger(plannedTypical)) {
-        issue(issues, `${path}.planned_typical_critical_path_ms`, 'must be a non-negative integer number of milliseconds');
-    }
-    else if (plannedTypicalCriticalPathMs !== null &&
-        plannedTypical !== plannedTypicalCriticalPathMs) {
-        issue(issues, `${path}.planned_typical_critical_path_ms`, `must equal the computed typical planning path ${plannedTypicalCriticalPathMs}; it is not a true expected makespan`);
-    }
-    const emptyLegacyHighAlias = steps.length === 0 &&
-        phase.planned_high_critical_path_ms === undefined &&
-        phase.reported_conservative_component_p95_critical_path_ms === 0;
-    const plannedHigh = emptyLegacyHighAlias ? 0 : phase.planned_high_critical_path_ms;
-    if (!isNonnegativeInteger(plannedHigh)) {
-        issue(issues, `${path}.planned_high_critical_path_ms`, 'must be a non-negative integer number of milliseconds');
-    }
-    else if (plannedHighCriticalPathMs !== null &&
-        plannedHigh !== plannedHighCriticalPathMs) {
-        issue(issues, `${path}.planned_high_critical_path_ms`, `must equal the computed high planning path ${plannedHighCriticalPathMs}; it is not an observed or statistical phase p95`);
-    }
-    if (phase.reported_expected_critical_path_ms !== undefined &&
-        !emptyLegacyPlanningAlias) {
-        issue(issues, `${path}.reported_expected_critical_path_ms`, 'can imply a true expected makespan; use planned_typical_critical_path_ms');
-    }
-    if (phase.reported_conservative_component_p95_critical_path_ms !== undefined &&
-        !emptyLegacyHighAlias) {
-        issue(issues, `${path}.reported_conservative_component_p95_critical_path_ms`, 'can imply a statistical phase p95; use planned_high_critical_path_ms');
-    }
-    if (phase.reported_p95_critical_path_ms !== undefined) {
-        issue(issues, `${path}.reported_p95_critical_path_ms`, 'is ambiguous; use planned_high_critical_path_ms or hot_launch.observed_end_to_end_p95_ms');
-    }
-    return {
-        stepIds,
-        producedPreparedStateIds,
-        plannedTypicalCriticalPathMs,
-        plannedHighCriticalPathMs,
-        steps,
-    };
-}
-function validateExactPreparedStateIdentity(state, path, workloadProfileIds, workloadProfilesById, compatibilityGroupIds, evidenceById, issues) {
-    const exactIdentity = mappingAt(state, 'exact_identity', `${path}.exact_identity`, issues);
-    if (exactIdentity) {
-        for (const key of [
-            'template_catalog_ref',
-            'resource_size',
-            'durable_snapshot_ref',
-            'source_cut_ref',
-        ]) {
-            if (!isNonemptyString(exactIdentity[key])) {
-                issue(issues, `${path}.exact_identity.${key}`, 'must be a non-empty opaque identity field');
-            }
-        }
-        for (const key of ['artifact_digest_refs', 'config_digest_refs']) {
-            const value = exactIdentity[key];
-            if (!Array.isArray(value) || value.length === 0 || value.some((entry) => !isNonemptyString(entry))) {
-                issue(issues, `${path}.exact_identity.${key}`, 'must be a non-empty list of opaque digest references');
-            }
-        }
-        const workloadProfileId = checkId(exactIdentity.workload_profile_id, `${path}.exact_identity.workload_profile_id`, workloadProfileIds, issues);
-        checkId(exactIdentity.compatibility_group_id, `${path}.exact_identity.compatibility_group_id`, compatibilityGroupIds, issues);
-        const profile = workloadProfileId
-            ? workloadProfilesById.get(workloadProfileId)
-            : undefined;
-        if (profile) {
-            for (const key of ['template_catalog_ref', 'resource_size']) {
-                if (exactIdentity[key] !== profile[key]) {
-                    issue(issues, `${path}.exact_identity.${key}`, `must exactly match materialization_plan.workload_profiles entry "${workloadProfileId}"`);
-                }
-            }
-        }
-    }
-    const stateEvidenceIds = checkEvidenceIdList(state.evidence_ids, `${path}.evidence_ids`, evidenceById, issues, true);
-    if (typeof state.id === 'string') {
-        requireEvidenceSubjectLinks(stateEvidenceIds, `${path}.evidence_ids`, [state.id], evidenceById, issues);
-    }
-}
-function validateGeneratedCaseRuns(value, path, achievedGeneratedCaseFanout, issues) {
-    if (!Array.isArray(value)) {
-        issue(issues, path, 'must be a list of exact generated-case run identities', 'evidence.yml');
-        return;
-    }
-    if (isPositiveInteger(achievedGeneratedCaseFanout) &&
-        value.length !== achievedGeneratedCaseFanout) {
-        issue(issues, path, 'must contain exactly one run identity for each achieved generated case', 'evidence.yml');
-    }
-    const seenByField = new Map(GENERATED_CASE_IDENTITY_FIELDS.map((field) => [field, new Set()]));
-    value.forEach((entry, index) => {
-        const entryPath = `${path}[${index}]`;
-        if (!isRecord(entry)) {
-            issue(issues, entryPath, 'must be a mapping', 'evidence.yml');
-            return;
-        }
-        GENERATED_CASE_IDENTITY_FIELDS.forEach((field) => {
-            const id = entry[field];
-            if (typeof id !== 'string' || !STABLE_ID.test(id)) {
-                issue(issues, `${entryPath}.${field}`, 'must be a lowercase kebab-case stable ID', 'evidence.yml');
-                return;
-            }
-            const seen = seenByField.get(field);
-            if (seen?.has(id)) {
-                issue(issues, `${entryPath}.${field}`, `duplicate exact ${field} "${id}"`, 'evidence.yml');
-            }
-            seen?.add(id);
-        });
-    });
-}
-function validateHotPathProbeEvidence(hot, readinessScope, injection, freshUniversePerGeneratedCase, consumedPreparedStateIds, achievedGeneratedCaseFanout, evidenceById, issues) {
-    const path = 'materialization_plan.hot_launch.probe_evidence_ids';
-    const ids = checkEvidenceIdList(hot.probe_evidence_ids, path, evidenceById, issues, true);
-    const expectedEnvironmentScope = readinessScope === 'real-production'
-        ? 'hosted-production'
-        : 'production-reference';
-    const requiredSubjectIds = [
-        ...consumedPreparedStateIds,
-        ...(typeof injection?.step_id === 'string' ? [injection.step_id] : []),
-        ...(typeof freshUniversePerGeneratedCase?.step_id === 'string'
-            ? [freshUniversePerGeneratedCase.step_id]
-            : []),
-    ].filter((id, index, all) => all.indexOf(id) === index);
-    requireEvidenceSubjectLinks(ids, path, requiredSubjectIds, evidenceById, issues);
-    ids.forEach((id, index) => {
-        const evidence = evidenceById.get(id);
-        if (!evidence)
-            return;
-        const evidencePath = `${path}[${index}]`;
-        if (evidence.claim_kind !== 'materialization-hot-path-probe') {
-            issue(issues, evidencePath, `probe evidence "${id}" must use claim_kind "materialization-hot-path-probe"`);
-        }
-        if (evidence.confidence !== 'proven') {
-            issue(issues, evidencePath, `probe evidence "${id}" must have confidence "proven"`);
-        }
-        if (evidence.operational_status !== 'materialization-probed') {
-            issue(issues, evidencePath, `probe evidence "${id}" must have operational_status "materialization-probed"`);
-        }
-        if (evidence.latency_basis !== 'measured') {
-            issue(issues, evidencePath, `probe evidence "${id}" must have latency_basis "measured"`);
-        }
-        if (evidence.authority !== 'authoritative') {
-            issue(issues, evidencePath, `probe evidence "${id}" must be authoritative`);
-        }
-        if (evidence.environment_scope !== expectedEnvironmentScope) {
-            issue(issues, evidencePath, `probe evidence "${id}" must use environment_scope "${expectedEnvironmentScope}" for readiness scope "${String(readinessScope)}"; local or synthetic evidence cannot prove a real-production hot path`);
-        }
-        const hasTypedProbeSource = Array.isArray(evidence.sources) &&
-            evidence.sources.some((source) => isRecord(source) &&
-                isNonemptyString(source.source_ref) &&
-                typeof source.kind === 'string' &&
-                HOT_PATH_PROBE_SOURCE_KINDS.has(source.kind) &&
-                source.environment_scope === expectedEnvironmentScope);
-        if (!hasTypedProbeSource) {
-            issue(issues, evidencePath, `probe evidence "${id}" must cite a scope-compatible source_ref typed as a Haystack or provider materialization probe result; repository paths do not qualify`);
-        }
-        const results = isRecord(evidence.probe_results) ? evidence.probe_results : null;
-        if (!results) {
-            issue(issues, evidencePath, `probe evidence "${id}" must contain probe_results`);
-            return;
-        }
-        if (!isNonnegativeInteger(results.observed_end_to_end_p95_ms)) {
-            issue(issues, `${evidencePath}.probe_results.observed_end_to_end_p95_ms`, 'must be a non-negative integer number of measured milliseconds');
-        }
-        else if (results.observed_end_to_end_p95_ms !== hot.observed_end_to_end_p95_ms) {
-            issue(issues, `${evidencePath}.probe_results.observed_end_to_end_p95_ms`, 'must exactly match hot_launch.observed_end_to_end_p95_ms');
-        }
-        if (!isPositiveInteger(results.achieved_generated_case_fanout)) {
-            issue(issues, `${evidencePath}.probe_results.achieved_generated_case_fanout`, 'must be a positive integer');
-        }
-        else if (results.achieved_generated_case_fanout !== achievedGeneratedCaseFanout) {
-            issue(issues, `${evidencePath}.probe_results.achieved_generated_case_fanout`, 'must exactly match hot_launch.achieved_generated_case_fanout');
-        }
-        if (!isNonemptyString(results.verification_commit_ref)) {
-            issue(issues, `${evidencePath}.probe_results.verification_commit_ref`, 'must identify the arbitrary verification commit exercised by the probe');
-        }
-        for (const [key, expected] of [
-            ['arbitrary_verification_commit_injection', injection?.supported === true],
-            [
-                'fresh_universe_per_generated_case',
-                freshUniversePerGeneratedCase?.enforced === true,
-            ],
-            [
-                'parent_write_protected',
-                freshUniversePerGeneratedCase?.parent_write_protected === true,
-            ],
-            ['cleanup_covers_all_attempts_on_partial_failure', true],
-            ['single_absolute_deadline', true],
-        ]) {
-            if (results[key] !== true || expected !== true) {
-                issue(issues, `${evidencePath}.probe_results.${key}`, 'must be true and exactly match the enforced hot-launch property');
-            }
-        }
-        for (const [key, expected] of [
-            ['parallel_phases', GENERATED_CASE_PARALLEL_PHASES],
-            ['cleanup_order', GENERATED_CASE_CLEANUP_ORDER],
-        ]) {
-            if (!isExactStringSequence(results[key], expected)) {
-                issue(issues, `${evidencePath}.probe_results.${key}`, `must be exactly [${expected.join(', ')}]`, 'evidence.yml');
-            }
-        }
-        validateGeneratedCaseRuns(results.generated_case_runs, `${evidencePath}.probe_results.generated_case_runs`, achievedGeneratedCaseFanout, issues);
-    });
-}
-function validateHotPathInventoryCoverage(coldSteps, hotSteps, coverageSubjects, issues) {
-    const stepSubjectIds = new Set();
-    [...coldSteps, ...hotSteps].forEach((step) => {
-        if (!Array.isArray(step.subject_ids))
-            return;
-        step.subject_ids.forEach((id) => {
-            if (typeof id === 'string')
-                stepSubjectIds.add(id);
-        });
-    });
-    coverageSubjects.forEach((subject) => {
-        if (stepSubjectIds.has(subject.id))
-            return;
-        issue(issues, subject.path, `hot-path-proven requires mapped ${subject.kind} "${subject.id}" to be named by at least one cold_preparation.steps[].subject_ids or hot_launch.steps[].subject_ids entry`);
-    });
-}
-export function validateMaterializationPlan(value, context, issues, required) {
-    if (value === undefined && !required)
-        return;
-    if (!isRecord(value)) {
-        issue(issues, 'materialization_plan', 'must be a mapping');
-        return;
-    }
-    const plan = value;
-    if (!isPositiveInteger(plan.verifier_total_slo_ms)) {
-        issue(issues, 'materialization_plan.verifier_total_slo_ms', 'must be a positive integer');
-    }
-    if (!isPositiveInteger(plan.target_slo_ms)) {
-        issue(issues, 'materialization_plan.target_slo_ms', 'must be a positive integer hot-launch allocation');
-    }
-    if (isPositiveInteger(plan.verifier_total_slo_ms) &&
-        isPositiveInteger(plan.target_slo_ms) &&
-        plan.target_slo_ms >= plan.verifier_total_slo_ms) {
-        issue(issues, 'materialization_plan.target_slo_ms', 'must be strictly smaller than verifier_total_slo_ms to reserve time for case generation, execution, and aggregation');
-    }
-    if (!isPositiveInteger(plan.reserved_case_work_ms)) {
-        issue(issues, 'materialization_plan.reserved_case_work_ms', 'must be a positive integer');
-    }
-    else if (isPositiveInteger(plan.verifier_total_slo_ms) &&
-        isPositiveInteger(plan.target_slo_ms) &&
-        plan.reserved_case_work_ms !== plan.verifier_total_slo_ms - plan.target_slo_ms) {
-        issue(issues, 'materialization_plan.reserved_case_work_ms', 'must equal verifier_total_slo_ms minus target_slo_ms');
-    }
-    const generatedCaseFanout = mappingAt(plan, 'generated_case_fanout', 'materialization_plan.generated_case_fanout', issues);
-    if (generatedCaseFanout) {
-        if (!isPositiveInteger(generatedCaseFanout.target_n)) {
-            issue(issues, 'materialization_plan.generated_case_fanout.target_n', 'must be a positive integer');
-        }
-        if (!isPositiveInteger(generatedCaseFanout.hard_max_n)) {
-            issue(issues, 'materialization_plan.generated_case_fanout.hard_max_n', 'must be a positive integer hard bound');
-        }
-        else {
-            if (generatedCaseFanout.hard_max_n > MAX_GENERATED_CASE_FANOUT) {
-                issue(issues, 'materialization_plan.generated_case_fanout.hard_max_n', `must be at or below the product hard ceiling ${MAX_GENERATED_CASE_FANOUT}`);
-            }
-            if (isPositiveInteger(generatedCaseFanout.target_n) &&
-                generatedCaseFanout.target_n > generatedCaseFanout.hard_max_n) {
-                issue(issues, 'materialization_plan.generated_case_fanout.target_n', 'must be at or below hard_max_n');
-            }
-        }
-        if (!isExactStringSequence(generatedCaseFanout.required_identity_fields, GENERATED_CASE_IDENTITY_FIELDS)) {
-            issue(issues, 'materialization_plan.generated_case_fanout.required_identity_fields', `must be exactly [${GENERATED_CASE_IDENTITY_FIELDS.join(', ')}]`);
-        }
-        if (!isExactStringSequence(generatedCaseFanout.parallel_phases, GENERATED_CASE_PARALLEL_PHASES)) {
-            issue(issues, 'materialization_plan.generated_case_fanout.parallel_phases', `must be exactly [${GENERATED_CASE_PARALLEL_PHASES.join(', ')}]`);
-        }
-        if (!isExactStringSequence(generatedCaseFanout.cleanup_order, GENERATED_CASE_CLEANUP_ORDER)) {
-            issue(issues, 'materialization_plan.generated_case_fanout.cleanup_order', `must be exactly [${GENERATED_CASE_CLEANUP_ORDER.join(', ')}]`);
-        }
-        if (generatedCaseFanout.cleanup_covers_all_attempts_on_partial_failure !== true) {
-            issue(issues, 'materialization_plan.generated_case_fanout.cleanup_covers_all_attempts_on_partial_failure', 'must be true');
-        }
-        if (generatedCaseFanout.single_absolute_deadline !== true) {
-            issue(issues, 'materialization_plan.generated_case_fanout.single_absolute_deadline', 'must be true');
-        }
-    }
-    const readiness = mappingAt(plan, 'readiness', 'materialization_plan.readiness', issues);
-    const readinessStatus = readiness?.status;
-    if (typeof readinessStatus !== 'string' || !READINESS_STATUSES.has(readinessStatus)) {
-        issue(issues, 'materialization_plan.readiness.status', 'must be "proposal", "cold-preparable", "hot-path-proven", or "blocked"');
-    }
-    if (typeof readiness?.scope !== 'string' || !READINESS_SCOPES.has(readiness.scope)) {
-        issue(issues, 'materialization_plan.readiness.scope', 'must be "real-production" or "synthetic-evaluation"');
-    }
-    if (readinessStatus === 'blocked' && !isNonemptyString(readiness?.reason)) {
-        issue(issues, 'materialization_plan.readiness.reason', 'must explain why readiness is blocked');
-    }
-    const baseUniverseIds = new Set(context.universeIds);
-    const workloadProfiles = recordsAt(plan, 'workload_profiles', 'materialization_plan.workload_profiles', issues, false);
-    const workloadProfileIds = registerIds(workloadProfiles, 'materialization_plan.workload_profiles', context.universeIds, issues);
-    const workloadProfilesById = new Map();
-    workloadProfiles.forEach((profile, index) => {
-        if (typeof profile.id === 'string' && workloadProfileIds.has(profile.id)) {
-            workloadProfilesById.set(profile.id, profile);
-        }
-        for (const key of ['template_catalog_ref', 'resource_size']) {
-            if (!isNonemptyString(profile[key])) {
-                issue(issues, `materialization_plan.workload_profiles[${index}].${key}`, 'must be a non-empty exact profile identity field');
-            }
-        }
-    });
-    const compatibilityGroups = recordsAt(plan, 'compatibility_groups', 'materialization_plan.compatibility_groups', issues, false);
-    const compatibilityGroupIds = registerIds(compatibilityGroups, 'materialization_plan.compatibility_groups', context.universeIds, issues);
-    compatibilityGroups.forEach((group, index) => {
-        checkIdList(group.member_subject_ids, `materialization_plan.compatibility_groups[${index}].member_subject_ids`, baseUniverseIds, issues, { nonempty: true });
-    });
-    const preparedStates = recordsAt(plan, 'prepared_states', 'materialization_plan.prepared_states', issues);
-    const preparedStateIds = registerIds(preparedStates, 'materialization_plan.prepared_states', context.universeIds, issues);
-    preparedStates.forEach((state, index) => validateExactPreparedStateIdentity(state, `materialization_plan.prepared_states[${index}]`, workloadProfileIds, workloadProfilesById, compatibilityGroupIds, context.evidenceById, issues));
-    const cold = mappingAt(plan, 'cold_preparation', 'materialization_plan.cold_preparation', issues);
-    const hot = mappingAt(plan, 'hot_launch', 'materialization_plan.hot_launch', issues);
-    if (!cold || !hot)
-        return;
-    const refresh = mappingAt(cold, 'refresh', 'materialization_plan.cold_preparation.refresh', issues);
-    if (refresh) {
-        if (typeof refresh.strategy !== 'string' || !REFRESH_STRATEGIES.has(refresh.strategy)) {
-            issue(issues, 'materialization_plan.cold_preparation.refresh.strategy', 'must be "scheduled", "on-source-cut-change", "continuous", or "manual"');
-        }
-        if (!isPositiveInteger(refresh.max_age_seconds)) {
-            issue(issues, 'materialization_plan.cold_preparation.refresh.max_age_seconds', 'must be a positive integer freshness bound');
-        }
-        checkEvidenceIdList(refresh.freshness_evidence_ids, 'materialization_plan.cold_preparation.refresh.freshness_evidence_ids', context.evidenceById, issues, readinessStatus === 'cold-preparable' || readinessStatus === 'hot-path-proven');
-    }
-    const coldRequiredStatus = readinessStatus === 'cold-preparable' || readinessStatus === 'hot-path-proven'
-        ? 'adapter-verified'
-        : 'declared';
-    const coldResult = validatePhase(cold, 'cold_preparation', context.universeIds, context.universeIds, preparedStateIds, context.evidenceById, issues, coldRequiredStatus);
-    const hotRequiredStatus = readinessStatus === 'hot-path-proven'
-        ? 'materialization-probed'
-        : 'declared';
-    const hotResult = validatePhase(hot, 'hot_launch', context.universeIds, context.universeIds, preparedStateIds, context.evidenceById, issues, hotRequiredStatus);
-    const consumedPreparedStateIds = checkIdList(hot.consumes_prepared_state_ids, 'materialization_plan.hot_launch.consumes_prepared_state_ids', preparedStateIds, issues, { nonempty: readinessStatus === 'hot-path-proven' });
-    if (readinessStatus === 'cold-preparable' || readinessStatus === 'hot-path-proven') {
-        if (preparedStates.length === 0) {
-            issue(issues, 'materialization_plan.prepared_states', `must be non-empty for readiness status "${readinessStatus}"`);
-        }
-        if (coldResult.steps.length === 0) {
-            issue(issues, 'materialization_plan.cold_preparation.steps', `must be non-empty for readiness status "${readinessStatus}"`);
-        }
-        preparedStateIds.forEach((id) => {
-            if (!coldResult.producedPreparedStateIds.has(id)) {
-                issue(issues, 'materialization_plan.cold_preparation.steps', `prepared state "${id}" must be produced by a cold-preparation step`);
-            }
-        });
-    }
-    consumedPreparedStateIds.forEach((id) => {
-        if (!coldResult.producedPreparedStateIds.has(id)) {
-            issue(issues, 'materialization_plan.hot_launch.consumes_prepared_state_ids', `consumed prepared state "${id}" must be produced by cold_preparation`);
-        }
-    });
-    const injection = mappingAt(hot, 'arbitrary_verification_commit_injection', 'materialization_plan.hot_launch.arbitrary_verification_commit_injection', issues);
-    if (injection) {
-        if (typeof injection.supported !== 'boolean') {
-            issue(issues, 'materialization_plan.hot_launch.arbitrary_verification_commit_injection.supported', 'must be a boolean');
-        }
-        if (injection.supported === true) {
-            checkId(injection.step_id, 'materialization_plan.hot_launch.arbitrary_verification_commit_injection.step_id', hotResult.stepIds, issues);
-            checkEvidenceIdList(injection.production_recipe_equivalence_evidence_ids, 'materialization_plan.hot_launch.arbitrary_verification_commit_injection.production_recipe_equivalence_evidence_ids', context.evidenceById, issues, true);
-        }
-    }
-    const freshUniversePerGeneratedCase = mappingAt(hot, 'fresh_universe_per_generated_case', 'materialization_plan.hot_launch.fresh_universe_per_generated_case', issues);
-    if (freshUniversePerGeneratedCase) {
-        if (typeof freshUniversePerGeneratedCase.enforced !== 'boolean') {
-            issue(issues, 'materialization_plan.hot_launch.fresh_universe_per_generated_case.enforced', 'must be a boolean');
-        }
-        if (freshUniversePerGeneratedCase.enforced === true) {
-            checkId(freshUniversePerGeneratedCase.step_id, 'materialization_plan.hot_launch.fresh_universe_per_generated_case.step_id', hotResult.stepIds, issues);
-            if (freshUniversePerGeneratedCase.parent_write_protected !== true) {
-                issue(issues, 'materialization_plan.hot_launch.fresh_universe_per_generated_case.parent_write_protected', 'must be true when generated-case universe isolation is enforced');
-            }
-        }
-    }
-    if (hot.achieved_generated_case_fanout !== undefined &&
-        !isNonnegativeInteger(hot.achieved_generated_case_fanout)) {
-        issue(issues, 'materialization_plan.hot_launch.achieved_generated_case_fanout', 'must be a non-negative integer');
-    }
-    if (hot.achieved_generated_case_fanout === undefined) {
-        issue(issues, 'materialization_plan.hot_launch.achieved_generated_case_fanout', 'must be a non-negative integer');
-    }
-    if (isPositiveInteger(generatedCaseFanout?.hard_max_n) &&
-        isNonnegativeInteger(hot.achieved_generated_case_fanout) &&
-        hot.achieved_generated_case_fanout > generatedCaseFanout.hard_max_n) {
-        issue(issues, 'materialization_plan.hot_launch.achieved_generated_case_fanout', 'must not exceed materialization_plan.generated_case_fanout.hard_max_n');
-    }
-    if (typeof hot.latency_basis !== 'string' || !LATENCY_BASES.has(hot.latency_basis)) {
-        issue(issues, 'materialization_plan.hot_launch.latency_basis', 'must be "assumed" or "measured"');
-    }
-    if (hot.observed_end_to_end_p95_ms !== undefined &&
-        !isNonnegativeInteger(hot.observed_end_to_end_p95_ms)) {
-        issue(issues, 'materialization_plan.hot_launch.observed_end_to_end_p95_ms', 'must be a non-negative integer number of measured milliseconds when present');
-    }
-    if (readinessStatus === 'hot-path-proven') {
-        validateHotPathInventoryCoverage(coldResult.steps, hotResult.steps, context.coverageSubjects, issues);
-        if (hotResult.steps.length === 0) {
-            issue(issues, 'materialization_plan.hot_launch.steps', 'must be non-empty for hot-path-proven');
-        }
-        if (injection?.supported !== true) {
-            issue(issues, 'materialization_plan.hot_launch.arbitrary_verification_commit_injection.supported', 'must be true for hot-path-proven');
-        }
-        if (freshUniversePerGeneratedCase?.enforced !== true) {
-            issue(issues, 'materialization_plan.hot_launch.fresh_universe_per_generated_case.enforced', 'must be true for hot-path-proven');
-        }
-        if (hot.latency_basis !== 'measured') {
-            issue(issues, 'materialization_plan.hot_launch.latency_basis', 'must be "measured" for hot-path-proven');
-        }
-        if (!isNonnegativeInteger(hot.observed_end_to_end_p95_ms)) {
-            issue(issues, 'materialization_plan.hot_launch.observed_end_to_end_p95_ms', 'must report a measured end-to-end p95 for hot-path-proven');
-        }
-        else if (isPositiveInteger(plan.target_slo_ms) &&
-            hot.observed_end_to_end_p95_ms > plan.target_slo_ms) {
-            issue(issues, 'materialization_plan.hot_launch.observed_end_to_end_p95_ms', 'must be at or below the hot-launch allocation materialization_plan.target_slo_ms for hot-path-proven');
-        }
-        if (isPositiveInteger(generatedCaseFanout?.target_n) &&
-            (!isPositiveInteger(hot.achieved_generated_case_fanout) ||
-                hot.achieved_generated_case_fanout < generatedCaseFanout.target_n)) {
-            issue(issues, 'materialization_plan.hot_launch.achieved_generated_case_fanout', 'must be at least materialization_plan.generated_case_fanout.target_n for hot-path-proven');
-        }
-        hotResult.steps.forEach((step, index) => {
-            if (step.latency_basis !== 'measured') {
-                issue(issues, `materialization_plan.hot_launch.steps[${index}].latency_basis`, 'must be "measured" for hot-path-proven');
-            }
-        });
-        validateHotPathProbeEvidence(hot, readiness?.scope, injection, freshUniversePerGeneratedCase, consumedPreparedStateIds, hot.achieved_generated_case_fanout, context.evidenceById, issues);
-    }
-}