@open-agent-toolkit/cli 0.1.43 → 0.1.46

package/dist/commands/project/dispatch-ceiling/index.js

@@ -4,11 +4,13 @@ import { buildCommandContext, } from '../../../app/command-context.js';
 import { getFrontmatterBlock } from '../../shared/frontmatter.js';
 import { readGlobalOptions } from '../../shared/shared.utils.js';
 import { compileDispatchPolicyPreset, } from '../../../config/dispatch-ceiling-preset.js';
-import { resolveActiveProject, VALID_CLAUDE_DISPATCH_CEILINGS, VALID_CODEX_DISPATCH_CEILINGS, VALID_MANAGED_DISPATCH_POLICIES, } from '../../../config/oat-config.js';
+import { getDispatchPolicyChoices, managedDispatchPolicyValueList, renderDispatchPolicyChoicesMarkdown, } from '../../../config/dispatch-policy-options.js';
+import { resolveActiveProject, VALID_CLAUDE_DISPATCH_CEILINGS, VALID_CODEX_DISPATCH_CEILINGS, VALID_DISPATCH_MATRIX_TIERS, VALID_MANAGED_DISPATCH_POLICIES, validateDispatchRouteTarget, } from '../../../config/oat-config.js';
 import { resolveEffectiveConfig, } from '../../../config/resolve.js';
 import { resolveProjectRoot } from '../../../fs/paths.js';
 import TOML from '@iarna/toml';
 import { getCeilingAdapter, } from '../../../providers/ceiling/registry.js';
+import { classifyModelFamily, } from '../../../providers/identity/family.js';
 import { Command } from 'commander';
 import YAML from 'yaml';
 const CODEX_VALUES = [
@@ -54,7 +56,7 @@ function isValidProviderValue(provider, value) {
         return (typeof value === 'string' &&
             CLAUDE_VALUES.includes(value));
     }
-    return false;
+    return typeof value === 'string' && value.trim().length > 0;
 }
 function configSourceToCeilingSource(source) {
     if (source === 'local') {
@@ -105,7 +107,7 @@ function isValidManagedPolicy(value) {
         VALID_MANAGED_DISPATCH_POLICIES.includes(value));
 }
 function validManagedPolicyList() {
-    return VALID_MANAGED_DISPATCH_POLICIES.join(', ');
+    return managedDispatchPolicyValueList(', ');
 }
 function validProviderValueList(provider) {
     return providerValueOrder(provider)?.join(', ') ?? 'none';
@@ -121,6 +123,253 @@ function invalidProjectPolicyMessage(value) {
     const actual = typeof value === 'string' ? value : String(value);
     return `Invalid project dispatch policy "${actual}". Valid managed policies: ${validManagedPolicyList()}. Use mode "inherit" for host defaults.`;
 }
+function normalizeProjectMatrixBareValue(provider, value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const order = providerValueOrder(provider);
+    if (order && !isValidProviderValue(provider, trimmed)) {
+        return undefined;
+    }
+    return trimmed;
+}
+function normalizeProjectMatrixRouteTarget(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const record = value;
+    const target = {};
+    for (const key of ['harness', 'model', 'effort']) {
+        const rawValue = record[key];
+        if (typeof rawValue === 'string' && rawValue.trim()) {
+            target[key] = rawValue.trim();
+        }
+    }
+    return Object.keys(target).length > 0 ? target : undefined;
+}
+function normalizeProjectMatrixCell(provider, value) {
+    const bareValue = normalizeProjectMatrixBareValue(provider, value);
+    if (bareValue !== undefined) {
+        return bareValue;
+    }
+    if (!Array.isArray(value) || value.length === 0) {
+        return undefined;
+    }
+    const route = [];
+    for (const entry of value) {
+        const bareEntry = normalizeProjectMatrixBareValue(provider, entry);
+        if (bareEntry !== undefined) {
+            route.push(bareEntry);
+            continue;
+        }
+        const target = normalizeProjectMatrixRouteTarget(entry);
+        if (target !== undefined) {
+            route.push(target);
+        }
+    }
+    return route.length > 0 ? route : undefined;
+}
+function normalizeProjectMatrixProviderValue(provider, value) {
+    const bareValue = normalizeProjectMatrixBareValue(provider, value);
+    if (bareValue !== undefined) {
+        return bareValue;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const tierMap = {};
+    for (const [tier, rawCell] of Object.entries(value)) {
+        if (!VALID_DISPATCH_MATRIX_TIERS.includes(tier)) {
+            continue;
+        }
+        const normalized = normalizeProjectMatrixCell(provider, rawCell);
+        if (normalized !== undefined) {
+            tierMap[tier] = normalized;
+        }
+    }
+    return Object.keys(tierMap).length > 0 ? tierMap : undefined;
+}
+function readProjectDispatchMatrix(value) {
+    if (value === undefined || value === null) {
+        return { matrix: null, warnings: [] };
+    }
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        return {
+            matrix: null,
+            warnings: [
+                'Ignoring malformed oat_dispatch_policy.matrix in project state.',
+            ],
+        };
+    }
+    const matrix = {};
+    for (const [provider, rawProviderValue] of Object.entries(value)) {
+        if (!provider.trim()) {
+            continue;
+        }
+        const normalized = normalizeProjectMatrixProviderValue(provider, rawProviderValue);
+        if (normalized !== undefined) {
+            matrix[provider] = normalized;
+        }
+    }
+    if (Object.keys(matrix).length === 0) {
+        return {
+            matrix: null,
+            warnings: [
+                'Ignoring malformed oat_dispatch_policy.matrix in project state.',
+            ],
+        };
+    }
+    return { matrix, warnings: [] };
+}
+function policyTier(policy) {
+    return typeof policy === 'string' &&
+        VALID_DISPATCH_MATRIX_TIERS.includes(policy)
+        ? policy
+        : null;
+}
+function uncappedPreferredTier(provider, role, preferredValue) {
+    if (provider !== 'codex' || role === 'reviewer' || preferredValue === null) {
+        return null;
+    }
+    if (VALID_DISPATCH_MATRIX_TIERS.includes(preferredValue)) {
+        return preferredValue;
+    }
+    let matchedTier = null;
+    for (const tier of VALID_DISPATCH_MATRIX_TIERS) {
+        const compiledValue = compiledPolicyValueForProvider(provider, compileDispatchPolicyPreset(tier));
+        if (compiledValue === preferredValue) {
+            matchedTier = tier;
+        }
+    }
+    return matchedTier;
+}
+function dispatchValueFromRouteTarget(target) {
+    const adapter = getCeilingAdapter(target.harness);
+    if (adapter.mechanism === 'pinned-variant') {
+        return target.effort ?? null;
+    }
+    if (adapter.mechanism === 'model-arg') {
+        return target.model ?? null;
+    }
+    return null;
+}
+function routeTargetFromBareValue(provider, value, routeIndex, routeLength) {
+    const adapter = getCeilingAdapter(provider);
+    const target = {
+        harness: provider,
+        crossHarness: false,
+        routeIndex,
+        routeLength,
+    };
+    if (adapter.mechanism === 'pinned-variant') {
+        target.effort = value;
+    }
+    else {
+        target.model = value;
+    }
+    return target;
+}
+function routeTargetFromObject(provider, target, routeIndex, routeLength) {
+    const harness = target.harness ?? provider;
+    return {
+        harness,
+        ...(target.model ? { model: target.model } : {}),
+        ...(target.effort ? { effort: target.effort } : {}),
+        crossHarness: harness !== provider,
+        routeIndex,
+        routeLength,
+    };
+}
+function resolveRouteMatrixCell(provider, route, escalationLevel, cellSource) {
+    const routeIndex = Math.min(escalationLevel, route.length - 1);
+    const entry = route[routeIndex];
+    if (entry === undefined) {
+        return null;
+    }
+    const target = typeof entry === 'string'
+        ? routeTargetFromBareValue(provider, entry, routeIndex, route.length)
+        : routeTargetFromObject(provider, entry, routeIndex, route.length);
+    const targetValidation = typeof entry === 'string'
+        ? { valid: true }
+        : validateDispatchRouteTarget(provider, entry);
+    const value = targetValidation.valid
+        ? typeof entry === 'string'
+            ? entry
+            : dispatchValueFromRouteTarget(target)
+        : null;
+    const warnings = targetValidation.valid
+        ? []
+        : [
+            `Ignoring incomplete Codex dispatch target at route index ${routeIndex}: ${targetValidation.reason}`,
+        ];
+    return {
+        value,
+        cellSource,
+        target,
+        selectionBranch: routeIndex > 0 ? 'escalation-target' : 'matrix-pinned',
+        warnings,
+    };
+}
+function resolveProviderCellFromValue(provider, providerValue, tier, cellSource, escalationLevel) {
+    if (providerValue === undefined) {
+        return null;
+    }
+    if (typeof providerValue === 'string') {
+        return {
+            value: providerValue,
+            cellSource,
+            target: null,
+            selectionBranch: 'prompt-persisted',
+            warnings: [],
+        };
+    }
+    if (tier === null) {
+        return null;
+    }
+    const cell = providerValue[tier];
+    if (cell === undefined) {
+        return null;
+    }
+    if (typeof cell === 'string') {
+        return {
+            value: cell,
+            cellSource,
+            target: null,
+            selectionBranch: 'matrix-pinned',
+            warnings: [],
+        };
+    }
+    return resolveRouteMatrixCell(provider, cell, escalationLevel, cellSource);
+}
+function resolveProviderMatrixCell(provider, tier, resolvedConfig, projectMatrix, escalationLevel) {
+    let selected = null;
+    const layers = [
+        {
+            source: 'user-config',
+            providers: resolvedConfig.user.workflow?.dispatchCeiling?.providers,
+        },
+        {
+            source: 'repo-config',
+            providers: resolvedConfig.shared.workflow?.dispatchCeiling?.providers,
+        },
+        {
+            source: 'local-config',
+            providers: resolvedConfig.local.workflow?.dispatchCeiling?.providers,
+        },
+        { source: 'project-state', providers: projectMatrix },
+    ];
+    for (const layer of layers) {
+        const resolved = resolveProviderCellFromValue(provider, layer.providers?.[provider], tier, layer.source, escalationLevel);
+        if (resolved) {
+            selected = resolved;
+        }
+    }
+    return selected;
+}
 function readProjectDispatchPolicy(provider, content) {
     const frontmatter = getFrontmatterBlock(content);
     if (!frontmatter) {
@@ -135,6 +384,7 @@ function readProjectDispatchPolicy(provider, content) {
         return null;
     }
     const policyRecord = policy;
+    const parsedMatrix = readProjectDispatchMatrix(policyRecord['matrix']);
     const mode = policyRecord['mode'];
     if (mode === 'inherit') {
         return {
@@ -143,6 +393,11 @@ function readProjectDispatchPolicy(provider, content) {
             value: null,
             source: 'project-state',
             preset: null,
+            matrix: parsedMatrix.matrix,
+            cellSource: null,
+            target: null,
+            selectionBranch: 'inherit',
+            warnings: parsedMatrix.warnings,
         };
     }
     if (mode !== 'managed') {
@@ -161,6 +416,11 @@ function readProjectDispatchPolicy(provider, content) {
             value: null,
             source: 'project-state',
             preset: policyValue,
+            matrix: parsedMatrix.matrix,
+            cellSource: null,
+            target: null,
+            selectionBranch: 'prompt-persisted',
+            warnings: parsedMatrix.warnings,
         };
     }
     const providers = policyRecord['providers'];
@@ -183,6 +443,11 @@ function readProjectDispatchPolicy(provider, content) {
         value,
         source: 'project-state',
         preset: policyValue,
+        matrix: parsedMatrix.matrix,
+        cellSource: 'project-state',
+        target: null,
+        selectionBranch: 'prompt-persisted',
+        warnings: parsedMatrix.warnings,
     };
 }
 function readLegacyProjectDispatchCeiling(provider, parsed) {
@@ -208,6 +473,11 @@ function readLegacyProjectDispatchCeiling(provider, parsed) {
         value,
         source: 'project-state',
         preset: typeof presetValue === 'string' ? presetValue : null,
+        matrix: null,
+        cellSource: 'project-state',
+        target: null,
+        selectionBranch: 'prompt-persisted',
+        warnings: [],
     };
 }
 function readProjectDispatchCeiling(provider, content) {
@@ -274,6 +544,11 @@ function stripConfigCandidateSource(candidate) {
         value: candidate.value,
         source: candidate.source,
         preset: candidate.preset,
+        matrix: candidate.matrix,
+        cellSource: candidate.cellSource,
+        target: candidate.target,
+        selectionBranch: candidate.selectionBranch,
+        warnings: candidate.warnings,
     };
 }
 function readResolvedConfigPolicyCandidate(provider, resolvedConfig) {
@@ -291,6 +566,11 @@ function readResolvedConfigPolicyCandidate(provider, resolvedConfig) {
             value: null,
             source,
             preset: null,
+            matrix: null,
+            cellSource: null,
+            target: null,
+            selectionBranch: 'inherit',
+            warnings: [],
             configSource: modeEntry.source,
         };
     }
@@ -311,6 +591,11 @@ function readResolvedConfigPolicyCandidate(provider, resolvedConfig) {
             value: compiledPolicyValueForProvider(provider, compiled),
             source,
             preset: policy,
+            matrix: null,
+            cellSource: null,
+            target: null,
+            selectionBranch: 'prompt-persisted',
+            warnings: [],
             configSource,
         };
     }
@@ -336,6 +621,11 @@ function readResolvedLegacyConfigCeilingCandidate(provider, resolvedConfig) {
         value: entry.value,
         source,
         preset: null,
+        matrix: null,
+        cellSource: source,
+        target: null,
+        selectionBranch: 'prompt-persisted',
+        warnings: [],
         configSource: entry.source,
     };
 }
@@ -384,11 +674,28 @@ function normalizePreferredValue(provider, value) {
     }
     return normalized;
 }
+function normalizeEscalationLevel(value) {
+    if (value === undefined) {
+        return 0;
+    }
+    const normalized = value.trim();
+    if (!/^\d+$/.test(normalized)) {
+        throw new Error(`Invalid escalation level "${value}". Use a non-negative integer.`);
+    }
+    return Number.parseInt(normalized, 10);
+}
+function selectionFamily(provider, value, target) {
+    return value
+        ? classifyModelFamily({ value, providerId: target?.harness ?? provider })
+        : 'unknown';
+}
 function selectDispatchValue(provider, role, policy, preferredValue) {
     const baseSelection = {
         role,
         policyMode: policy.mode,
         policy: policy.policy,
+        cellSource: policy.cellSource,
+        target: policy.target,
     };
     if (policy.mode === 'inherit') {
         return {
@@ -397,15 +704,30 @@ function selectDispatchValue(provider, role, policy, preferredValue) {
             selectedValue: null,
             capped: false,
             selectionMode: 'inherit-default',
+            selectionBranch: 'inherit',
+            family: 'unknown',
+            target: null,
         };
     }
     if (policy.policy === 'uncapped') {
+        const targetValue = policy.target
+            ? dispatchValueFromRouteTarget(policy.target)
+            : null;
+        const selectedValue = role === 'reviewer' ? null : (targetValue ?? preferredValue);
+        const target = role === 'reviewer' || !targetValue ? null : policy.target;
         return {
             ...baseSelection,
             preferredValue: role === 'reviewer' ? null : preferredValue,
-            selectedValue: role === 'reviewer' ? null : preferredValue,
+            selectedValue,
             capped: false,
             selectionMode: role === 'reviewer' ? 'no-review-target' : 'uncapped',
+            selectionBranch: target
+                ? policy.selectionBranch
+                : selectedValue
+                    ? 'prompt-persisted'
+                    : 'unresolved',
+            family: selectionFamily(provider, selectedValue, target),
+            target,
         };
     }
     if (policy.value === null) {
@@ -414,7 +736,10 @@ function selectDispatchValue(provider, role, policy, preferredValue) {
             preferredValue: null,
             selectedValue: null,
             capped: false,
-            selectionMode: 'capped',
+            selectionMode: policy.target ? 'unresolved' : 'capped',
+            selectionBranch: policy.selectionBranch,
+            family: 'unknown',
+            target: policy.target,
         };
     }
     if (role === 'reviewer' || preferredValue === null) {
@@ -424,6 +749,8 @@ function selectDispatchValue(provider, role, policy, preferredValue) {
             selectedValue: policy.value,
             capped: false,
             selectionMode: role === 'reviewer' ? 'review-target' : 'capped',
+            selectionBranch: policy.selectionBranch,
+            family: selectionFamily(provider, policy.value, policy.target),
         };
     }
     const order = providerValueOrder(provider);
@@ -436,17 +763,57 @@ function selectDispatchValue(provider, role, policy, preferredValue) {
             selectedValue: policy.value,
             capped: false,
             selectionMode: 'capped',
+            selectionBranch: policy.selectionBranch,
+            family: selectionFamily(provider, policy.value, policy.target),
         };
     }
     const selectedIndex = Math.min(preferredIndex, ceilingIndex);
+    const selectedValue = order[selectedIndex];
     return {
         ...baseSelection,
         preferredValue,
-        selectedValue: order[selectedIndex],
+        selectedValue,
         capped: preferredIndex > ceilingIndex,
         selectionMode: 'capped',
+        selectionBranch: policy.selectionBranch,
+        family: selectionFamily(provider, selectedValue, selectedValue === policy.value ? policy.target : null),
+        target: selectedValue === policy.value ? policy.target : null,
     };
 }
+function hasCodexVariantDispatchArgs(dispatchArgs) {
+    return (dispatchArgs !== null &&
+        'variant' in dispatchArgs &&
+        typeof dispatchArgs.variant === 'string' &&
+        dispatchArgs.variant.length > 0);
+}
+function hasModelDispatchArgs(dispatchArgs) {
+    return (dispatchArgs !== null &&
+        'model' in dispatchArgs &&
+        typeof dispatchArgs.model === 'string' &&
+        dispatchArgs.model.length > 0);
+}
+function modelAxis(selection, dispatchArgs) {
+    if (selection.target?.model && dispatchArgs) {
+        return `selected:${selection.target.model}`;
+    }
+    if (hasModelDispatchArgs(dispatchArgs)) {
+        return `selected:${dispatchArgs.model}`;
+    }
+    if (selection.selectionMode === 'inherit-default') {
+        return 'inherited';
+    }
+    return 'unresolved';
+}
+function codexEffortAxis(selection, dispatchArgs) {
+    if (hasCodexVariantDispatchArgs(dispatchArgs) && selection.target?.effort) {
+        return `selected:${selection.target.effort}`;
+    }
+    if (selection.selectionMode === 'inherit-default' ||
+        selection.selectionMode === 'no-review-target') {
+        return 'provider-default';
+    }
+    return 'unresolved';
+}
 /**
  * Join a resolved ceiling value with the active provider's adapter to compute
  * the enforcement mode, mechanism, dispatch args, and verify-on-upgrade flag.
@@ -460,13 +827,21 @@ function buildProviderResolution(provider, policy, role, orchestratorTier, prefe
             mode: adapter.supportsCeiling ? 'advisory' : 'unsupported',
             mechanism: adapter.mechanism,
             dispatchArgs: null,
+            modelAxis: 'unresolved',
+            effortAxis: provider === 'codex' ? 'provider-default' : 'not-applicable',
             verifyOnDispatch: false,
+            cellSource: null,
+            target: null,
             selection: {
                 role,
                 preferredValue,
                 selectedValue: null,
                 capped: false,
                 selectionMode: 'unresolved',
+                selectionBranch: 'unresolved',
+                family: 'unknown',
+                target: null,
+                cellSource: null,
                 policyMode: null,
                 policy: null,
             },
@@ -474,9 +849,11 @@ function buildProviderResolution(provider, policy, role, orchestratorTier, prefe
     }
     const selection = selectDispatchValue(provider, role, policy, preferredValue);
     const dispatchValue = selection.selectedValue;
-    const dispatchArgs = dispatchValue
+    const isCrossHarness = selection.target?.crossHarness === true;
+    const dispatchArgs = dispatchValue && !isCrossHarness
         ? adapter.compileToDispatchArgs(dispatchValue, role, {
             orchestratorTier,
+            target: selection.target,
         })
         : null;
     let mode;
@@ -494,11 +871,18 @@ function buildProviderResolution(provider, policy, role, orchestratorTier, prefe
         mode,
         mechanism: adapter.mechanism,
         dispatchArgs,
-        verifyOnDispatch: dispatchValue
+        modelAxis: modelAxis(selection, dispatchArgs),
+        effortAxis: provider === 'codex'
+            ? codexEffortAxis(selection, dispatchArgs)
+            : 'not-applicable',
+        verifyOnDispatch: dispatchValue && !isCrossHarness
             ? adapter.verifyOnDispatch(dispatchValue, {
                 orchestratorTier,
+                target: selection.target,
             })
             : false,
+        cellSource: policy.cellSource,
+        target: selection.target,
         selection,
     };
 }
@@ -550,7 +934,11 @@ async function resolveDispatchCeiling(context, dependencies, options) {
         ? await resolveCodexProviderDefaultEffort(repoRoot, context, dependencies)
         : 'not-applicable';
     const preferredValue = normalizePreferredValue(provider, options.preferred);
-    const resolvedValue = await resolveCeilingValue(provider, resolvedConfig, projectPath, dependencies);
+    const escalationLevel = normalizeEscalationLevel(options.escalationLevel);
+    const resolvedValue = await resolveCeilingValue(provider, resolvedConfig, projectPath, dependencies, escalationLevel, role, preferredValue);
+    for (const warning of resolvedValue?.warnings ?? []) {
+        context.logger.warn(warning);
+    }
     const providerResolution = buildProviderResolution(provider, resolvedValue, role, orchestratorTier, preferredValue);
     const providers = {
         [provider]: providerResolution,
@@ -567,6 +955,7 @@ async function resolveDispatchCeiling(context, dependencies, options) {
             unresolved: false,
             projectPath,
             providerDefaultEffort,
+            matrix: resolvedValue.matrix,
             providers,
         };
     }
@@ -585,6 +974,7 @@ async function resolveDispatchCeiling(context, dependencies, options) {
         unresolved: true,
         projectPath,
         providerDefaultEffort,
+        matrix: null,
         providers,
         message,
     };
@@ -595,16 +985,50 @@ async function resolveDispatchCeiling(context, dependencies, options) {
  * Never reads the preset label for dispatch — the preset is surfaced as
  * provenance only.
  */
-async function resolveCeilingValue(provider, resolvedConfig, projectPath, dependencies) {
+async function resolveCeilingValue(provider, resolvedConfig, projectPath, dependencies, escalationLevel, role, preferredValue) {
     const configCeiling = readResolvedConfigCeiling(provider, resolvedConfig);
-    if (configCeiling) {
-        return configCeiling;
-    }
     const projectCeiling = await resolveProjectStateCeiling(provider, projectPath, dependencies);
-    if (projectCeiling) {
-        return projectCeiling;
+    const baseCeiling = configCeiling ?? projectCeiling;
+    if (!baseCeiling) {
+        return null;
     }
-    return null;
+    if (baseCeiling.mode === 'inherit') {
+        return baseCeiling;
+    }
+    if (baseCeiling.policy === 'uncapped') {
+        const preferredTier = uncappedPreferredTier(provider, role, preferredValue);
+        if (preferredTier) {
+            const matrixCell = resolveProviderMatrixCell(provider, preferredTier, resolvedConfig, projectCeiling?.matrix ?? null, escalationLevel);
+            if (matrixCell) {
+                return {
+                    ...baseCeiling,
+                    cellSource: matrixCell.cellSource,
+                    target: matrixCell.target,
+                    selectionBranch: matrixCell.selectionBranch,
+                    warnings: [...baseCeiling.warnings, ...matrixCell.warnings],
+                };
+            }
+        }
+        return baseCeiling;
+    }
+    const tier = policyTier(baseCeiling.policy);
+    const matrixCell = resolveProviderMatrixCell(provider, tier, resolvedConfig, projectCeiling?.matrix ?? null, escalationLevel);
+    if (matrixCell) {
+        return {
+            ...baseCeiling,
+            value: matrixCell.value,
+            cellSource: matrixCell.cellSource,
+            target: matrixCell.target,
+            selectionBranch: matrixCell.selectionBranch,
+            warnings: [...baseCeiling.warnings, ...matrixCell.warnings],
+        };
+    }
+    if (baseCeiling.policy !== 'legacy-ceiling' &&
+        baseCeiling.value === null &&
+        providerValueOrder(provider) === null) {
+        return null;
+    }
+    return baseCeiling;
 }
 function policyLabel(policy) {
     if (policy === 'legacy-ceiling') {
@@ -625,6 +1049,23 @@ function writeHumanResolution(context, resolution) {
     if (providerResolution) {
         context.logger.info(`Mode: ${providerResolution.mode} (${providerResolution.mechanism})`);
         context.logger.info(`Selection: ${providerResolution.selection.selectionMode}`);
+        if (providerResolution.target) {
+            const details = [
+                `harness=${providerResolution.target.harness}`,
+                providerResolution.target.model
+                    ? `model=${providerResolution.target.model}`
+                    : null,
+                providerResolution.target.effort
+                    ? `effort=${providerResolution.target.effort}`
+                    : null,
+            ]
+                .filter(Boolean)
+                .join(' ');
+            const suffix = providerResolution.target.crossHarness
+                ? ' (cross-harness target; native dispatch args deferred)'
+                : '';
+            context.logger.info(`Dispatch target: ${details}${suffix}`);
+        }
     }
     if (resolution.provider === 'codex') {
         context.logger.info(`Codex provider default effort: ${resolution.providerDefaultEffort}`);
@@ -681,18 +1122,47 @@ async function runDispatchCeilingResolve(context, dependencies, options) {
         process.exitCode = 1;
     }
 }
+async function runDispatchCeilingChoices(context, options) {
+    const choices = getDispatchPolicyChoices();
+    const format = (options.format ?? 'markdown').trim().toLowerCase();
+    if (context.json || options.json) {
+        context.logger.json({ status: 'ok', choices });
+        process.exitCode = 0;
+        return;
+    }
+    if (format !== 'markdown') {
+        context.logger.error(`Invalid choices format "${options.format}". Valid formats: markdown.`);
+        process.exitCode = 1;
+        return;
+    }
+    context.logger.info(renderDispatchPolicyChoicesMarkdown(choices));
+    process.exitCode = 0;
+}
 export function createProjectDispatchCeilingCommand(overrides = {}) {
     const dependencies = {
         ...DEFAULT_DEPENDENCIES,
         ...overrides,
     };
     const command = new Command('dispatch-ceiling').description('Resolve OAT project dispatch ceiling metadata');
+    command.addCommand(new Command('choices')
+        .description('Print canonical dispatch policy choices')
+        .option('--format <format>', 'Output format: markdown', 'markdown')
+        .option('--json', 'Output machine-readable JSON')
+        .action(async (options, cmd) => {
+        const globalOptions = readGlobalOptions(cmd);
+        const context = dependencies.buildCommandContext({
+            ...globalOptions,
+            json: globalOptions.json === true || options.json === true,
+        });
+        await runDispatchCeilingChoices(context, options);
+    }));
     command.addCommand(new Command('resolve')
         .description('Resolve dispatch policy for a provider')
-        .requiredOption('--provider <provider>', 'Provider name: codex or claude are enforced; any other provider resolves as advisory (unsupported)')
+        .requiredOption('--provider <provider>', 'Provider name: codex, claude, or cursor are enforced; unregistered providers resolve as unsupported advisory')
         .option('--role <role>', 'Dispatch role for variant compilation: implementer (default) or reviewer')
         .option('--orchestrator-tier <tier>', 'Orchestrator tier, used to flag verify-on-upgrade for above-orchestrator requests')
         .option('--preferred <value>', 'Preferred implementer/fix dispatch value before applying the resolved policy')
+        .option('--escalation-level <level>', 'Ordered route entry to select; 0 is the floor and higher values advance through escalation targets')
         .option('--project-path <path>', 'Read project-state policy from an explicit project path')
         .option('--preflight', 'Treat unresolved non-interactive resolution as an implementation block')
         .option('--non-interactive', 'Force non-interactive block behavior when the ceiling is unresolved')