@aiwg/cli 2026.10.11 → 2026.10.12

package/dist/src/models/provider-policy.js

@@ -5,43 +5,18 @@
  */
 import Ajv2020 from 'ajv/dist/2020.js';
 import addFormats from 'ajv-formats';
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
-import { integer, dateTime, url, number } from '../schema/zod-validation.mjs';
-import { createRequire } from 'node:module';
-import { compileWorkerVersionPattern, workerVersionRangeMismatch } from './worker-installation.mjs';
-import { normalizeProviderDefinitionId } from '../providers/provider-definitions.js';
-import { qualificationDigest } from './qualification-digest.mjs';
-import { DEFAULT_WORKER_SELECTION, WorkerSelectionPolicySchema, workerModelKey, ownWorkerRoleGuidance } from './worker-selection-policy.js';
+import { url } from '../schema/zod-validation.mjs';
+import { compileWorkerVersionPattern } from './worker-installation.mjs';
+import { ProviderSchema, requireModelResource } from './policy-resources.js';
+import { resetCatalogPolicyCache, validateWorkerModelObservation } from './catalog-policy.js';
+import { hasSelectionRelevantConflicts } from './worker-review-lineage.js';
+export { hasSelectionRelevantConflicts } from './worker-review-lineage.js';
+export * from './catalog-policy.js';
+export * from './worker-invocation-policy.js';
+import { DEFAULT_WORKER_SELECTION, workerModelKey, ownWorkerRoleGuidance } from './worker-selection-policy.js';
 export { DEFAULT_WORKER_SELECTION, WorkerSelectionPolicySchema, mergeWorkerSelection, workerModelKey, isCanonicalWorkerModelKey } from './worker-selection-policy.js';
-const require = createRequire(import.meta.url);
-function requireModelResource(filename) {
-    const candidates = [
-        `./${filename}`,
-        `../../agentic/code/providers/${filename}`,
-        `../../../agentic/code/providers/${filename}`,
-        `../../schemas/models/${filename}`,
-        `../../../schemas/models/${filename}`,
-    ];
-    for (const candidate of candidates) {
-        try {
-            return require(candidate);
-        }
-        catch (error) {
-            if (error?.code !== 'MODULE_NOT_FOUND')
-                throw error;
-        }
-    }
-    throw new Error(`Model policy resource is missing: ${filename}`);
-}
 const capabilityData = requireModelResource('model-capabilities.v1.json');
-const catalogData = requireModelResource('model-catalog.v1.json');
-const ProviderSchema = z.enum([
-    'antigravity', 'claude', 'codex', 'copilot', 'cursor', 'deepseek-harness', 'factory', 'grokbot', 'grok-build', 'hermes',
-    'muse', 'opencode', 'openclaw', 'openhuman', 'omp', 'pi', 'warp', 'windsurf',
-]);
 const OutcomeSchema = z.enum([
     'native', 'compiled', 'inherited', 'global-only', 'informational', 'unsupported',
 ]);
@@ -103,112 +78,7 @@ const CapabilityRegistrySchema = z.strictObject({
     workerHealthAdapters: z.record(z.string().regex(/^[a-z][a-z0-9-]{0,62}$/), WorkerAdapterSchema)
         .refine(value => Object.keys(value).length <= 128, 'At most 128 worker health descriptors').optional(),
 });
-const CatalogModelSchema = z.object({
-    id: z.string().min(1),
-    status: z.enum(['active', 'deprecated', 'unverified']),
-    fallback: z.string().min(1).optional(),
-    observed: z.boolean().optional(),
-});
-const CatalogProviderSchema = z.object({
-    roles: z.object({
-        reasoning: CatalogModelSchema,
-        coding: CatalogModelSchema,
-        efficiency: CatalogModelSchema,
-    }),
-    sourceUrl: url(),
-    verifiedAt: z.string().date(),
-});
-let catalogValidators;
-function getCatalogValidators() {
-    if (!catalogValidators) {
-        const here = dirname(fileURLToPath(import.meta.url));
-        const file = [resolve(here, '../../schemas/models/model-catalog.v1.schema.json'), resolve(here, '../../../schemas/models/model-catalog.v1.schema.json')].find(existsSync);
-        if (!file)
-            throw new Error('Model catalog schema is unavailable');
-        const schema = JSON.parse(readFileSync(file, 'utf8'));
-        const ajv = addFormats(new Ajv2020({ strict: false, allErrors: true }));
-        ajv.addSchema(schema);
-        catalogValidators = { catalog: ajv.getSchema(schema.$id), observation: ajv.compile({ $ref: `${schema.$id}#/$defs/workerObservation` }), discovery: ajv.compile({ $ref: `${schema.$id}#/properties/discovery` }) };
-    }
-    return catalogValidators;
-}
-export function validateWorkerModelObservation(input) {
-    const validate = getCatalogValidators().observation;
-    return validate(input) ? [] : (validate.errors ?? []).map(error => `${error.instancePath}: ${error.message}`);
-}
-const WorkerObservationSchema = z.custom(input => validateWorkerModelObservation(input).length === 0);
-const DiscoveredWorkerModelSchema = z.looseObject({
-    id: z.string().min(1), apiModelId: z.string().optional(), llmProvider: z.string().optional(),
-    hidden: z.boolean().optional(), reasoningEfforts: z.array(z.string()).optional(), worker: WorkerObservationSchema.optional(),
-}).superRefine((model, context) => {
-    if (!model.worker)
-        return;
-    if (model.hidden !== undefined && model.worker.visibility !== (model.hidden ? 'hidden' : 'listed'))
-        context.addIssue({ code: 'custom', path: ['worker', 'visibility'], message: 'Conflicting visibility evidence' });
-    const efforts = model.reasoningEfforts ?? [];
-    const observed = model.worker.efforts.map(e => e.id);
-    if (efforts.length !== observed.length || new Set(observed).size !== observed.length || efforts.some(e => !observed.includes(e)))
-        context.addIssue({ code: 'custom', path: ['worker', 'efforts'], message: 'Conflicting effort evidence' });
-});
-const ProviderDiscoverySchema = z.looseObject({
-    provider: z.string(), source: z.enum(['native', 'cache', 'remote', 'static']), observedAt: dateTime({ offset: true }),
-    runtimeVersion: z.string().optional(), accountScope: z.enum(['local-account', 'local-runtime', 'public-feed', 'static']),
-    accountBinding: z.string().min(1).optional(), models: z.array(DiscoveredWorkerModelSchema),
-});
-const DiscoverySchema = z.strictObject({
-    source: z.enum(['native', 'cache', 'remote', 'static']), upstreamSource: z.enum(['native', 'remote', 'static']).optional(),
-    fetchedAt: dateTime({ offset: true }), remoteUrl: url().optional(), remoteError: z.string().optional(),
-    inventorySignature: z.string().optional(), providers: z.record(z.string(), ProviderDiscoverySchema),
-    instances: z.record(z.string(), ProviderDiscoverySchema).optional(),
-});
-/** Optional enrichment is checked without tightening legacy catalog rows. */
-export function validateWorkerCatalogDiscovery(input) {
-    if (input === undefined)
-        return [];
-    const validate = getCatalogValidators().discovery;
-    if (!validate(input))
-        return (validate.errors ?? []).map(error => `${error.instancePath}: ${error.message}`);
-    const parsed = DiscoverySchema.safeParse(input);
-    return parsed.success ? [] : parsed.error.issues.map(issue => `${issue.path.join('/')}: ${issue.message}`);
-}
-const CatalogSchema = z.strictObject({
-    version: z.literal('1.0.0'),
-    $schema: z.literal('../../../schemas/models/model-catalog.v1.schema.json').optional(),
-    discovery: DiscoverySchema.optional(),
-    refreshedAt: z.string().date(),
-    staleAfterDays: integer().positive(),
-    providers: z.partialRecord(ProviderSchema, CatalogProviderSchema),
-});
-const PolicySchema = z.strictObject({
-    role: z.enum(['reasoning', 'coding', 'efficiency']),
-    tier: z.enum(['economy', 'standard', 'premium']),
-    effort: z.enum(['minimal', 'low', 'medium', 'high', 'xhigh']).optional(),
-    override: z.string().min(1).optional(),
-});
-const UserProjectModelConfigSchema = z.looseObject({
-    defaults: z.strictObject({
-        tier: z.enum(['economy', 'standard', 'premium', 'max-quality']).optional(),
-        provider: ProviderSchema.optional(),
-        workerSelection: WorkerSelectionPolicySchema.optional(),
-    }).optional(),
-    agentOverrides: z.record(z.string(), z.strictObject({
-        'model-tier': z.enum(['economy', 'standard', 'premium', 'max-quality']).optional(),
-        'model-override': z.string().min(1).optional(),
-        rationale: z.string().min(1).optional(),
-    })).optional(),
-    customTiers: z.record(z.string(), z.strictObject({
-        description: z.string().min(1),
-        costMultiplier: number().check(z.gte(0)).meta({ type: 'number', minimum: 0 }),
-        roleMapping: z.strictObject({
-            reasoning: z.enum(['reasoning', 'coding', 'efficiency']),
-            coding: z.enum(['reasoning', 'coding', 'efficiency']),
-            efficiency: z.enum(['reasoning', 'coding', 'efficiency']),
-        }),
-    })).optional(),
-    rationale: z.string().optional(),
-});
 let registryCache = null;
-let catalogCache = null;
 export function loadProviderModelCapabilities() {
     if (!registryCache) {
         registryCache = parseProviderModelCapabilities(capabilityData);
@@ -345,410 +215,9 @@ export function assertWorkerSelectionAllowed(selected, context) {
         }
     }
 }
-const WORKER_CONTROLS = ['model', 'effort', 'sandbox', 'approval', 'workdir',
-    'finalOutput', 'stdin', 'structuredOutput', 'stepCap', 'trust', 'children', 'fallback'];
-/** Caller controls only add restrictions. Absent resolved authority, require all controls. */
-export function requiredWorkerControls(context) {
-    if (context.requiredControls !== undefined && (!Array.isArray(context.requiredControls)
-        || context.requiredControls.some(name => typeof name !== 'string' || !name))) {
-        throw new Error('Worker required controls must be an array of control names');
-    }
-    const controls = new Set(WORKER_CONTROLS);
-    if (context.policy && context.permissions) {
-        if (context.effort === null)
-            controls.delete('effort');
-        // Step limits are observed unless explicitly required by the trusted route.
-        controls.delete('stepCap');
-        if (context.policy.guards?.denySelfDelegation === false)
-            controls.delete('children');
-    }
-    for (const name of context.requiredControls ?? [])
-        controls.add(name);
-    return [...controls];
-}
-/** The same sandbox requirement governs inspection, resolution and rendering. */
-export function requiresWorkerExternalBoundary(adapter, selection) {
-    if (hasOperatorWorkerNativeRenderer(adapter)
-        && (selection.permissions?.sandbox !== 'external' || selection.transport === 'shell'))
-        return false;
-    const providers = [adapter.id, adapter.provider].map(normalizeProviderDefinitionId);
-    return requiredWorkerControls(selection).includes('sandbox')
-        && (providers.some(provider => provider && ['claude', 'muse', 'hermes'].includes(provider))
-            || adapter.invocationProfiles?.[selection.profile]?.controls.sandbox?.support === 'external'
-            || selection.permissions?.sandbox === 'external');
-}
-/** Explicit local operator approval for the direct CLI baseline (decision 17).
- * This is not backend attestation or a live negative-fixture result. */
-export const WORKER_OPERATOR_APPROVAL = 'aiwg doctor --probe-workers --qualify';
-export function isOperatorQualifiedWorkerAdapter(adapter) {
-    return adapter.qualification.status === 'qualified'
-        && adapter.qualification.evidenceRef === WORKER_OPERATOR_APPROVAL;
-}
-/** Bundled renderers with an independently checked native direct baseline. */
-export function hasOperatorWorkerNativeRenderer(adapter) {
-    return isOperatorQualifiedWorkerAdapter(adapter) && ['codex', 'muse'].includes(adapter.provider)
-        && adapter.invocation.kind === 'process';
-}
-/** The process-group launch boundary requires the independently verified native renderer. */
-export function assertWorkerLaunchMode(adapter, permissions = {}) {
-    const mode = permissions.launchMode ?? 'systemd-unit';
-    if (!['systemd-unit', 'native-sandbox'].includes(mode)) {
-        throw new WorkerPolicyError('OG_CONFIG_REFERENCE', 'Unknown worker launch mode');
-    }
-    if (mode === 'native-sandbox' && (!hasOperatorWorkerNativeRenderer(adapter)
-        || !['read-only', 'workspace-write'].includes(permissions.sandbox ?? '')
-        || (permissions.transport ?? 'shell') !== 'shell')) {
-        throw new WorkerPolicyError('OG_POLICY_RELAXATION', 'native-sandbox requires a verified native read-only or workspace-write shell renderer');
-    }
-}
-/** Check the actual argv before granting the direct renderer exception. */
-export function assertOperatorWorkerNativeArgv(adapter, argv, selected, permissions) {
-    if (!hasOperatorWorkerNativeRenderer(adapter))
-        return;
-    const args = argv.slice(1);
-    const requirePair = (flag, value) => {
-        if (args.filter(token => token === flag).length !== 1 || args[args.indexOf(flag) + 1] !== value) {
-            throw new Error(`Requested native worker control is absent or ambiguous: ${flag}`);
-        }
-    };
-    const sandbox = permissions?.sandbox ?? 'workspace-write';
-    if (!['read-only', 'workspace-write', 'external'].includes(sandbox))
-        throw new Error('Requested sandbox has no verified native renderer');
-    if (adapter.provider === 'muse') {
-        requirePair('--provider', 'meta');
-        requirePair('--model', selected.model);
-        if (selected.effort.value === null)
-            throw new Error('Muse requires explicit effort');
-        requirePair('--reasoning-effort', selected.effort.value);
-        if ((permissions?.approval ?? 'never') !== 'never')
-            throw new Error('Muse direct worker approval requires never');
-        requirePair('--approval-mode', 'never');
-        requirePair('--approval-judge', 'off');
-        // #3685: Tier 0 Muse workers run in conductor-prepared worker trees, so
-        // project context must load. An argv without exactly one
-        // --trust-workspace would run with project_sources=0 (no project
-        // rules/skills/hooks) and is refused rather than silently degraded.
-        if (args.filter(token => token === '--trust-workspace').length !== 1) {
-            throw new Error('Requested native worker control is absent or ambiguous: --trust-workspace');
-        }
-        if (args.includes('--disable-sandbox') !== (sandbox === 'external')) {
-            throw new Error('Requested native worker sandbox control does not match');
-        }
-        if (sandbox === 'read-only' && (!args.includes('--disable-write') || !args.includes('--disable-shell'))) {
-            throw new Error('Requested native worker read-only control is absent');
-        }
-        if (args[0] !== 'exec')
-            throw new Error('Native worker controls could be overridden');
-        const seen = new Set();
-        for (let index = 1; index < args.length; index++) {
-            const flag = args[index];
-            if (seen.has(flag))
-                throw new Error('Native worker controls could be overridden');
-            seen.add(flag);
-            if (['--json', '--trust-workspace', '--disable-write', '--disable-shell', '--disable-sandbox'].includes(flag))
-                continue;
-            if (!['--provider', '--model', '--reasoning-effort', '--workspace', '--approval-mode', '--approval-judge',
-                '--max-model-steps', '--output-schema', '--prompt-file'].includes(flag) || index + 1 >= args.length) {
-                throw new Error('Native worker controls could be overridden');
-            }
-            index++;
-        }
-        return;
-    }
-    requirePair('-m', selected.model);
-    requirePair('-s', sandbox === 'external' ? 'danger-full-access' : sandbox);
-    if ((permissions?.approval ?? 'never') !== 'never')
-        throw new Error('Codex direct worker approval requires never');
-    for (const [name, value] of [['model_reasoning_effort', selected.effort.value], ['approval_policy', permissions?.approval ?? 'never']]) {
-        const overrides = args.flatMap((token, index) => token === '-c' ? [args[index + 1]] : [])
-            .filter(token => token?.split('=')[0] === name);
-        if (value === null || overrides.length !== 1 || overrides[0] !== `${name}=${JSON.stringify(value)}`) {
-            throw new Error(`Requested native worker control is absent or ambiguous: ${name}`);
-        }
-    }
-    // Permit only the bounded native command grammar. Alternate/combined flags,
-    // profiles and additional config overrides must not undo the checked pairs.
-    if (args[0] !== '--no-daemon' || args[1] !== 'exec' || !args.includes('--ignore-user-config')) {
-        throw new Error('Native worker controls could be overridden');
-    }
-    for (let index = 2; index < args.length; index++) {
-        const flag = args[index];
-        if (['--ignore-user-config', '--skip-git-repo-check', '--json'].includes(flag))
-            continue;
-        if (flag === '-' && index === args.length - 1)
-            continue;
-        if (!['-m', '-s', '-c', '-C', '-o'].includes(flag) || index + 1 >= args.length) {
-            throw new Error('Native worker controls could be overridden');
-        }
-        const value = args[++index];
-        if (flag === '-c' && !['model_reasoning_effort', 'approval_policy'].includes(value.split('=')[0])) {
-            throw new Error('Native worker controls could be overridden');
-        }
-    }
-}
-/** Inspect declared controls before installation evidence can be produced. This
- * does not authorize invocation; consumers must use qualifyWorkerInvocationProfile. */
-export function inspectWorkerInvocationProfile(adapter, selection) {
-    WorkerAdapterSchema.parse(adapter);
-    const profile = adapter.invocationProfiles?.[selection.profile];
-    if (adapter.qualification.status !== 'qualified' || !profile || profile.transport !== selection.transport) {
-        throw new Error('Worker transport/profile is unqualified');
-    }
-    // Shared range predicate (worker-installation.mjs): read-only surfaces
-    // (worker-direct-readiness.ts) reuse the same helper instead of
-    // re-deriving this inspector's range logic.
-    if (workerVersionRangeMismatch(selection.cliVersion, [adapter.supportedVersions, profile.supportedVersions]) !== null) {
-        throw new Error('Worker CLI version is outside qualified profile');
-    }
-    // The direct CLI baseline trusts the installed driver's bounded renderer.
-    // Explicit extra controls still require the existing qualified mappings.
-    if (hasOperatorWorkerNativeRenderer(adapter) && profile.transport === 'shell') {
-        if (selection.permissions?.sandbox && !['read-only', 'workspace-write', 'external'].includes(selection.permissions.sandbox)) {
-            throw new Error('Requested sandbox has no verified native renderer');
-        }
-        for (const name of selection.requiredControls ?? []) {
-            if (!['native', 'external'].includes(profile.controls[name]?.support)) {
-                throw new Error(`Required worker control is unqualified: ${name}`);
-            }
-        }
-        return profile;
-    }
-    const requiredControls = requiredWorkerControls(selection);
-    if (requiresWorkerExternalBoundary(adapter, selection)
-        && (!selection.boundary || !['os', 'executor'].includes(selection.boundary.kind)
-            || !selection.boundary.identity || !/^sha256:[a-f0-9]{64}$/.test(selection.boundary.digest)
-            || !selection.boundary.controls?.includes('sandbox'))) {
-        throw new Error('Required worker control sandbox needs a qualified external enforcing boundary');
-    }
-    for (const name of requiredControls) {
-        if ((name === 'children' && !adapter.capabilities.nestedAgentsControllable)
-            || (name === 'fallback' && !adapter.capabilities.nativeFallbackControllable)) {
-            throw new Error(`Required worker control is unqualified: ${name}`);
-        }
-        const control = profile.controls[name];
-        if (!control || !['native', 'external'].includes(control.support) || !control.mapping || !control.evidence) {
-            throw new Error(`Required worker control is unqualified: ${name}`);
-        }
-    }
-    if (selection.transport === 'mcp' && (!selection.mcp || !profile.mcp
-        || Object.keys(profile.mcp).some(key => profile.mcp[key]
-            !== selection.mcp[key]))) {
-        throw new Error('MCP server/tool/schema/session qualification changed');
-    }
-    return profile;
-}
-/** Qualification is transport/version scoped; declaration or boundary claims
- * alone cannot qualify an external sandbox. The invocation owner rechecks the
- * installation scope, including this boundary, against the recorded digest. */
-export function qualifyWorkerInvocationProfile(adapter, selection) {
-    const profile = inspectWorkerInvocationProfile(adapter, selection);
-    if (isOperatorQualifiedWorkerAdapter(adapter) && selection.policy?.guards?.denySelfDelegation !== false
-        && !adapter.capabilities.nestedAgentsControllable) {
-        throw new Error('Required worker control is unqualified: children');
-    }
-    if (requiresWorkerExternalBoundary(adapter, selection) && !profile.installationQualification) {
-        throw new Error('Required worker control sandbox needs matching installation qualification for its external boundary');
-    }
-    return profile;
-}
-/** Health timing evidence belongs to the exact execution profile and tuple.
- * Fixture qualification does not become authenticated/live qualification. */
-export function workerHealthScopeDigest(profile, scope) {
-    const { installationQualification: _installation, health, ...executionProfile } = profile;
-    const { qualification: _qualification, ...signals } = health ?? {};
-    return qualificationDigest({ profile: executionProfile, health: signals,
-        profileRef: scope.profileRef, cliVersion: scope.cliVersion, accountScope: scope.accountScope,
-        modelKey: workerModelKey(scope.inferenceProvider, scope.model), effort: scope.effort });
-}
-/** Reused by observation and invocation owners before using qualified health.
- * Older profiles have no qualification record and retain degraded observation. */
-export function assertWorkerHealthQualification(profile, scope) {
-    const evidence = profile.health?.qualification;
-    if (!evidence)
-        return;
-    if (evidence.status === 'unqualified') {
-        if (profile.health?.coverage === 'full' || profile.health?.handshake === 'semantic') {
-            throw new Error('Unqualified worker health cannot assert full or semantic coverage');
-        }
-        return;
-    }
-    const modelKey = workerModelKey(scope.inferenceProvider, scope.model);
-    if (evidence.cliVersion !== scope.cliVersion || evidence.accountScope !== scope.accountScope
-        || evidence.profileRef !== scope.profileRef || evidence.modelKey !== modelKey || evidence.effort !== scope.effort
-        || !profile.health?.qualifiedAt || !Number.isFinite(Date.parse(profile.health.qualifiedAt))
-        || evidence.scopeDigest !== workerHealthScopeDigest(profile, scope)
-        || (evidence.status === 'live-qualified' && evidence.authorizedLive !== true)) {
-        throw new Error('Worker health qualification scope changed or lacks live authorization');
-    }
-}
-export function parseProviderModelCatalog(input) {
-    const validate = getCatalogValidators().catalog;
-    if (!validate(input))
-        throw new Error(`MODEL_POLICY_INVALID: ${validate.errors?.map(e => `${e.instancePath} ${e.message}`).join('; ')}`);
-    return CatalogSchema.parse(input);
-}
-export function loadProviderModelCatalog() {
-    if (!catalogCache)
-        catalogCache = parseProviderModelCatalog(catalogData);
-    return catalogCache;
-}
-export function validateCanonicalModelPolicy(input) {
-    const parsed = PolicySchema.safeParse(input);
-    if (!parsed.success) {
-        return {
-            valid: false,
-            diagnostics: parsed.error.issues.map(issue => ({
-                code: 'MODEL_POLICY_INVALID',
-                severity: 'error',
-                message: `${issue.path.join('.') || 'policy'}: ${issue.message}`,
-            })),
-        };
-    }
-    return { valid: true, policy: parsed.data, diagnostics: [] };
-}
-export function validateUserProjectModelConfig(input) {
-    const parsed = UserProjectModelConfigSchema.safeParse(input);
-    if (parsed.success)
-        return { valid: true, diagnostics: [] };
-    return {
-        valid: false,
-        diagnostics: parsed.error.issues.map(issue => ({
-            code: issue.path.includes('workerSelection') ? 'OG_CONFIG_REFERENCE' : 'MODEL_POLICY_INVALID',
-            pointer: `/${issue.path.map(p => String(p).replace(/~/g, '~0').replace(/\//g, '~1')).join('/')}`,
-            severity: 'error',
-            message: `${issue.path.join('.') || 'config'}: ${issue.message}`,
-        })),
-    };
-}
-function catalogRole(policy) {
-    if (policy.tier === 'economy')
-        return 'efficiency';
-    if (policy.tier === 'premium')
-        return 'reasoning';
-    return policy.role;
-}
-function fieldNames(provider) {
-    switch (provider) {
-        case 'antigravity': return { model: 'model', effort: 'effort' };
-        case 'codex': return { model: 'model', effort: 'model_reasoning_effort' };
-        case 'factory': return { model: 'model', effort: 'reasoningEffort' };
-        case 'claude': return { model: 'model', effort: 'effort' };
-        case 'copilot':
-        case 'cursor':
-        case 'opencode': return { model: 'model' };
-        case 'grok-build': return { model: 'model', effort: 'effort' };
-        case 'omp': return { model: 'model', effort: 'thinkingLevel' };
-        case 'pi': return { model: 'model', effort: 'thinking' };
-        case 'openhuman': return { model: 'model_hint' };
-        case 'openclaw': return { model: 'subagents.model' };
-        default: return {};
-    }
-}
-export function compileModelPolicy(input) {
-    const registry = loadProviderModelCapabilities();
-    const catalog = input.catalog ?? loadProviderModelCatalog();
-    const capability = registry.providers[input.provider];
-    if (!capability)
-        throw new Error(`Unknown provider model capability: ${input.provider}`);
-    const surface = capability[input.artifact];
-    const diagnostics = [];
-    const fields = {};
-    const names = fieldNames(input.provider);
-    const catalogProvider = catalog.providers[input.provider];
-    if (!catalogProvider)
-        throw new Error(`Unknown provider model catalog: ${input.provider}`);
-    const catalogEntry = catalogProvider.roles[catalogRole(input.policy)];
-    const effectiveModel = input.policy.override ?? catalogEntry.id;
-    if (surface === 'unsupported' || surface === 'informational') {
-        diagnostics.push({
-            code: surface === 'unsupported' ? 'MODEL_SURFACE_UNSUPPORTED' : 'MODEL_SURFACE_DEGRADED',
-            severity: surface === 'unsupported' ? 'warning' : 'info',
-            provider: input.provider,
-            message: `${input.provider} cannot enforce ${input.artifact}-scoped model policy (${surface})`,
-        });
-    }
-    else if (surface === 'global-only' || surface === 'inherited') {
-        diagnostics.push({
-            code: 'MODEL_SURFACE_DEGRADED', severity: 'warning', provider: input.provider,
-            message: `${input.provider} compiles ${input.artifact} policy as ${surface}`,
-        });
-    }
-    else if (names.model) {
-        fields[names.model] = effectiveModel;
-    }
-    if (input.policy.effort) {
-        if (names.effort && capability.effortValues?.includes(input.policy.effort)
-            && surface !== 'unsupported' && surface !== 'informational') {
-            fields[names.effort] = input.policy.effort;
-        }
-        else {
-            diagnostics.push({
-                code: 'MODEL_EFFORT_UNSUPPORTED', severity: 'warning', provider: input.provider,
-                message: `${input.provider} does not enforce effort=${input.policy.effort} on ${input.artifact} artifacts`,
-            });
-        }
-    }
-    if (input.policy.override) {
-        diagnostics.push({
-            code: 'MODEL_OVERRIDE_UNVERIFIED', severity: 'warning', provider: input.provider,
-            message: `Exact override ${input.policy.override} requires provider validation`,
-        });
-    }
-    else if (catalogEntry.status === 'deprecated') {
-        diagnostics.push({
-            code: 'MODEL_CATALOG_DEPRECATED', severity: 'error', provider: input.provider,
-            message: `${catalogEntry.id} is deprecated`,
-        });
-    }
-    else if (catalogEntry.status === 'unverified') {
-        diagnostics.push({
-            code: 'MODEL_CATALOG_UNVERIFIED', severity: 'warning', provider: input.provider,
-            message: `${catalogEntry.id} has not been observed on ${input.provider}`,
-        });
-    }
-    const now = input.now ?? new Date();
-    const refreshedAt = new Date(`${catalog.refreshedAt}T00:00:00Z`);
-    const ageDays = Math.floor((now.getTime() - refreshedAt.getTime()) / 86_400_000);
-    if (ageDays > catalog.staleAfterDays) {
-        diagnostics.push({
-            code: 'MODEL_CATALOG_STALE', severity: 'warning', provider: input.provider,
-            message: `Model catalog is ${ageDays} days old (limit ${catalog.staleAfterDays})`,
-        });
-    }
-    return {
-        provider: input.provider,
-        artifact: input.artifact,
-        outcome: surface,
-        effectiveModel: surface === 'unsupported' || surface === 'informational' ? undefined : effectiveModel,
-        effectiveEffort: fields[names.effort ?? ''] ? input.policy.effort : undefined,
-        fields,
-        target: capability.configTarget,
-        source: input.policy.override ? 'override' : (surface === 'inherited' ? 'inheritance' : 'catalog'),
-        diagnostics,
-    };
-}
-function tomlString(value) { return JSON.stringify(value); }
-export function renderCodexAgentToml(definition) {
-    const required = [
-        ['name', definition.name],
-        ['description', definition.description],
-        ['developer_instructions', definition.developerInstructions],
-    ];
-    for (const [field, value] of required) {
-        if (!value.trim())
-            throw new Error(`Codex custom agent requires ${field}`);
-    }
-    const lines = required.map(([field, value]) => `${field} = ${tomlString(value)}`);
-    if (definition.model)
-        lines.push(`model = ${tomlString(definition.model)}`);
-    if (definition.modelReasoningEffort) {
-        lines.push(`model_reasoning_effort = ${tomlString(definition.modelReasoningEffort)}`);
-    }
-    return `${lines.join('\n')}\n`;
-}
 export function resetModelPolicyCachesForTests() {
     registryCache = null;
-    catalogCache = null;
+    resetCatalogPolicyCache();
 }
 // Dispatch rechecks consume the effective policy from resolution. Keep these
 // predicates shared with route validation so defaults and restrictions agree.
@@ -794,11 +263,6 @@ function isWorkerEvidenceStale(observation, policy, now) {
     return observed > now || now - observed > blockHours * 3600000
         || (verified !== undefined && (verified > now || now - verified > policyDays * 86400000));
 }
-/** Optional catalog facts do not veto otherwise qualified selection. */
-export function hasSelectionRelevantConflicts(observation) {
-    const relevant = /^\/(?:lifecycle|availability|visibility|hidden|efforts|effortSupport|reasoningEfforts|sunsetAt|retiredAt|replacementModelId|supersededBy|dataUse|id|apiModelId|llmProvider|cliId|family|runtimeVersion|accountScope|endpointFingerprint|identityEvidence|contextTokens|maxOutputTokens|qualification)(?:\/|$)/;
-    return observation.conflicts?.some(conflict => relevant.test(conflict.field)) ?? false;
-}
 /** Validate a resolved route without launching or creating managed state. */
 export function validateWorkerPolicyRoute(input) {
     const diagnostics = [];

package/dist/src/models/resolver.js

@@ -5,6 +5,8 @@
  * @implements @.aiwg/architecture/ADR-015-enhanced-model-selection.md
  * @architecture @.aiwg/architecture/enhanced-model-selection-design.md
  */
+import { normalizeModelTier, TIER_ORDER, flagshipElected, isFlagshipModel } from './tiers.js';
+import { compileModelPolicy } from './provider-policy.js';
 import { ConfigLoader } from './config-loader.js';
 import { resolveWorkerPlan } from './worker-plan.js';
 export * from './worker-plan.js';
@@ -39,23 +41,39 @@ export class ModelResolver {
         const config = await this.getConfig();
         // Determine effective tier and role
         const { tier, role, source } = this.determineEffectiveTierAndRole(agentName, agentRole, agentTier, config);
+        if (normalizeModelTier(tier) === 'flagship' && !flagshipElected({ ...this.options, agentName })) {
+            throw new Error('Flagship models are user-elected only');
+        }
         // Check for direct model override (bypasses tier system)
         const override = config.agentOverrides[agentName];
         if (override?.['model-override']) {
+            if (isFlagshipModel(override['model-override']) && !flagshipElected({ ...this.options, agentName }))
+                throw new Error('Flagship models are user-elected only');
             return {
                 modelId: override['model-override'],
                 provider: this.options.provider || config.defaults.provider,
-                tier,
+                tier: normalizeModelTier(tier),
                 role,
                 source: 'agent',
             };
         }
-        // Resolve tier + role to concrete model
-        const modelId = this.resolveModelId(tier, role, config);
+        const provider = this.options.provider || config.defaults.provider;
+        const modelId = normalizeModelTier(tier) === 'flagship'
+            ? compileModelPolicy({
+                provider: provider === 'openai' ? 'codex' : provider,
+                artifact: 'agent', policy: { tier: 'flagship', role },
+                election: this.options.election, flagshipAllowlist: this.options.flagshipAllowlist, agentName,
+            }).effectiveModel
+            : this.resolveModelId(tier, role, config);
+        if (!modelId)
+            throw new Error(`No supported model binding for ${provider}/${tier}`);
+        if (isFlagshipModel(modelId) && !flagshipElected({ ...this.options, agentName })) {
+            throw new Error('Flagship models are user-elected only');
+        }
         return {
             modelId,
             provider: this.options.provider || config.defaults.provider,
-            tier,
+            tier: normalizeModelTier(tier),
             role,
             source,
         };
@@ -132,9 +150,9 @@ export class ModelResolver {
      * Return the higher of two tiers
      */
     maxTier(tier1, tier2) {
-        const tierOrder = ['economy', 'standard', 'premium', 'max-quality'];
-        const index1 = tierOrder.indexOf(tier1);
-        const index2 = tierOrder.indexOf(tier2);
+        const tierOrder = TIER_ORDER;
+        const index1 = tierOrder.indexOf(normalizeModelTier(tier1));
+        const index2 = tierOrder.indexOf(normalizeModelTier(tier2));
         return tierOrder[Math.max(index1, index2)];
     }
     /**
@@ -227,7 +245,7 @@ export class ModelResolver {
     async listTiers() {
         const config = await this.getConfig();
         return Object.entries(config.tiers).map(([tierName, tierDef]) => ({
-            tier: tierName,
+            tier: normalizeModelTier(tierName),
             description: tierDef.description,
             costMultiplier: tierDef.costMultiplier,
         }));