@open-agent-toolkit/cli 0.1.42 → 0.1.43

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

@@ -3,7 +3,8 @@ import { isAbsolute, join } from 'node:path';
 import { buildCommandContext, } from '../../../app/command-context.js';
 import { getFrontmatterBlock } from '../../shared/frontmatter.js';
 import { readGlobalOptions } from '../../shared/shared.utils.js';
-import { resolveActiveProject, } from '../../../config/oat-config.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 { resolveEffectiveConfig, } from '../../../config/resolve.js';
 import { resolveProjectRoot } from '../../../fs/paths.js';
 import TOML from '@iarna/toml';
@@ -11,15 +12,10 @@ import { getCeilingAdapter, } from '../../../providers/ceiling/registry.js';
 import { Command } from 'commander';
 import YAML from 'yaml';
 const CODEX_VALUES = [
-    'low',
-    'medium',
-    'high',
-    'xhigh',
+    ...VALID_CODEX_DISPATCH_CEILINGS,
 ];
 const CLAUDE_VALUES = [
-    'haiku',
-    'sonnet',
-    'opus',
+    ...VALID_CLAUDE_DISPATCH_CEILINGS,
 ];
 const DEFAULT_DEPENDENCIES = {
     buildCommandContext,
@@ -104,7 +100,28 @@ function providerLabel(provider) {
 function resolveTargetProjectPath(repoRoot, projectPath) {
     return isAbsolute(projectPath) ? projectPath : join(repoRoot, projectPath);
 }
-function readProjectDispatchCeiling(provider, content) {
+function isValidManagedPolicy(value) {
+    return (typeof value === 'string' &&
+        VALID_MANAGED_DISPATCH_POLICIES.includes(value));
+}
+function validManagedPolicyList() {
+    return VALID_MANAGED_DISPATCH_POLICIES.join(', ');
+}
+function validProviderValueList(provider) {
+    return providerValueOrder(provider)?.join(', ') ?? 'none';
+}
+function compiledPolicyValueForProvider(provider, compiled) {
+    if (!('providers' in compiled)) {
+        return null;
+    }
+    const value = compiled.providers[provider];
+    return isValidProviderValue(provider, value) ? value : null;
+}
+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 readProjectDispatchPolicy(provider, content) {
     const frontmatter = getFrontmatterBlock(content);
     if (!frontmatter) {
         return null;
@@ -113,6 +130,62 @@ function readProjectDispatchCeiling(provider, content) {
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
         return null;
     }
+    const policy = parsed['oat_dispatch_policy'];
+    if (!policy || typeof policy !== 'object' || Array.isArray(policy)) {
+        return null;
+    }
+    const policyRecord = policy;
+    const mode = policyRecord['mode'];
+    if (mode === 'inherit') {
+        return {
+            mode,
+            policy: null,
+            value: null,
+            source: 'project-state',
+            preset: null,
+        };
+    }
+    if (mode !== 'managed') {
+        const actual = typeof mode === 'string' ? mode : String(mode);
+        throw new Error(`Invalid project dispatch policy mode "${actual}". Valid modes: managed, inherit.`);
+    }
+    const policyValue = policyRecord['policy'];
+    if (!isValidManagedPolicy(policyValue)) {
+        throw new Error(invalidProjectPolicyMessage(policyValue));
+    }
+    const compiled = compileDispatchPolicyPreset(policyValue);
+    if (policyValue === 'uncapped') {
+        return {
+            mode,
+            policy: policyValue,
+            value: null,
+            source: 'project-state',
+            preset: policyValue,
+        };
+    }
+    const providers = policyRecord['providers'];
+    const explicitValue = providers && typeof providers === 'object' && !Array.isArray(providers)
+        ? providers[provider]
+        : null;
+    const providerOrder = providerValueOrder(provider);
+    if (providerOrder &&
+        explicitValue !== null &&
+        explicitValue !== undefined &&
+        !isValidProviderValue(provider, explicitValue)) {
+        throw new Error(`Invalid project dispatch policy provider value "${String(explicitValue)}" for ${provider}. Valid values: ${validProviderValueList(provider)}.`);
+    }
+    const value = isValidProviderValue(provider, explicitValue)
+        ? explicitValue
+        : compiledPolicyValueForProvider(provider, compiled);
+    return {
+        mode,
+        policy: policyValue,
+        value,
+        source: 'project-state',
+        preset: policyValue,
+    };
+}
+function readLegacyProjectDispatchCeiling(provider, parsed) {
     const ceiling = parsed['oat_dispatch_ceiling'];
     if (!ceiling || typeof ceiling !== 'object' || Array.isArray(ceiling)) {
         return null;
@@ -130,21 +203,37 @@ function readProjectDispatchCeiling(provider, content) {
     }
     const presetValue = ceilingRecord['preset'];
     return {
+        mode: 'managed',
+        policy: 'legacy-ceiling',
         value,
+        source: 'project-state',
         preset: typeof presetValue === 'string' ? presetValue : null,
     };
 }
+function readProjectDispatchCeiling(provider, content) {
+    const frontmatter = getFrontmatterBlock(content);
+    if (!frontmatter) {
+        return null;
+    }
+    const parsed = YAML.parse(frontmatter);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return null;
+    }
+    return (readProjectDispatchPolicy(provider, content) ??
+        readLegacyProjectDispatchCeiling(provider, parsed));
+}
 async function resolveProjectStateCeiling(provider, projectPath, dependencies) {
     if (!projectPath) {
         return null;
     }
+    let content;
     try {
-        const content = await dependencies.readFile(join(projectPath, 'state.md'));
-        return readProjectDispatchCeiling(provider, content);
+        content = await dependencies.readFile(join(projectPath, 'state.md'));
     }
     catch {
         return null;
     }
+    return readProjectDispatchCeiling(provider, content);
 }
 async function resolveProjectPath(repoRoot, dependencies, options) {
     if (options.projectPath) {
@@ -156,20 +245,115 @@ async function resolveProjectPath(repoRoot, dependencies, options) {
     }
     return join(repoRoot, activeProject.path);
 }
-function readResolvedConfigCeiling(provider, resolvedConfig) {
+function isConfigCandidateSource(source) {
+    return source !== undefined && source !== 'default';
+}
+function configSourcePrecedence(source) {
+    switch (source) {
+        case 'env':
+            return 4;
+        case 'local':
+            return 3;
+        case 'shared':
+            return 2;
+        case 'user':
+            return 1;
+        case 'default':
+            return 0;
+    }
+}
+function lowerPrecedenceConfigSource(left, right) {
+    return configSourcePrecedence(left) <= configSourcePrecedence(right)
+        ? left
+        : right;
+}
+function stripConfigCandidateSource(candidate) {
+    return {
+        mode: candidate.mode,
+        policy: candidate.policy,
+        value: candidate.value,
+        source: candidate.source,
+        preset: candidate.preset,
+    };
+}
+function readResolvedConfigPolicyCandidate(provider, resolvedConfig) {
+    const modeEntry = resolvedConfig.resolved['workflow.dispatchPolicy.mode'];
+    const policyEntry = resolvedConfig.resolved['workflow.dispatchPolicy.policy'];
+    if (modeEntry?.value === 'inherit' &&
+        isConfigCandidateSource(modeEntry.source)) {
+        const source = configSourceToCeilingSource(modeEntry.source);
+        if (source === null) {
+            return null;
+        }
+        return {
+            mode: 'inherit',
+            policy: null,
+            value: null,
+            source,
+            preset: null,
+            configSource: modeEntry.source,
+        };
+    }
+    if (modeEntry?.value === 'managed' &&
+        isValidManagedPolicy(policyEntry?.value) &&
+        isConfigCandidateSource(modeEntry.source) &&
+        isConfigCandidateSource(policyEntry?.source)) {
+        const policy = policyEntry.value;
+        const compiled = compileDispatchPolicyPreset(policy);
+        const configSource = lowerPrecedenceConfigSource(modeEntry.source, policyEntry.source);
+        const source = configSourceToCeilingSource(configSource);
+        if (source === null) {
+            return null;
+        }
+        return {
+            mode: 'managed',
+            policy,
+            value: compiledPolicyValueForProvider(provider, compiled),
+            source,
+            preset: policy,
+            configSource,
+        };
+    }
+    return null;
+}
+function readResolvedLegacyConfigCeilingCandidate(provider, resolvedConfig) {
     // Read the concrete per-provider value from the nested key. The flat
     // `workflow.dispatchCeiling.<provider>` shape was removed in p01; never read
     // the preset label for dispatch.
     const entry = resolvedConfig.resolved[`workflow.dispatchCeiling.providers.${provider}`];
-    const source = entry ? configSourceToCeilingSource(entry.source) : null;
-    if (!entry || !source || !isValidProviderValue(provider, entry.value)) {
+    if (!entry ||
+        !isConfigCandidateSource(entry.source) ||
+        !isValidProviderValue(provider, entry.value)) {
+        return null;
+    }
+    const source = configSourceToCeilingSource(entry.source);
+    if (source === null) {
         return null;
     }
     return {
+        mode: 'managed',
+        policy: 'legacy-ceiling',
         value: entry.value,
         source,
+        preset: null,
+        configSource: entry.source,
     };
 }
+function readResolvedConfigCeiling(provider, resolvedConfig) {
+    const policyCandidate = readResolvedConfigPolicyCandidate(provider, resolvedConfig);
+    const legacyCandidate = readResolvedLegacyConfigCeilingCandidate(provider, resolvedConfig);
+    if (!policyCandidate) {
+        return legacyCandidate ? stripConfigCandidateSource(legacyCandidate) : null;
+    }
+    if (!legacyCandidate) {
+        return stripConfigCandidateSource(policyCandidate);
+    }
+    const winner = configSourcePrecedence(policyCandidate.configSource) >=
+        configSourcePrecedence(legacyCandidate.configSource)
+        ? policyCandidate
+        : legacyCandidate;
+    return stripConfigCandidateSource(winner);
+}
 function normalizeRole(value) {
     return value === 'reviewer' ? 'reviewer' : 'implementer';
 }
@@ -200,32 +384,67 @@ function normalizePreferredValue(provider, value) {
     }
     return normalized;
 }
-function selectDispatchValue(provider, role, ceilingValue, preferredValue) {
+function selectDispatchValue(provider, role, policy, preferredValue) {
+    const baseSelection = {
+        role,
+        policyMode: policy.mode,
+        policy: policy.policy,
+    };
+    if (policy.mode === 'inherit') {
+        return {
+            ...baseSelection,
+            preferredValue: null,
+            selectedValue: null,
+            capped: false,
+            selectionMode: 'inherit-default',
+        };
+    }
+    if (policy.policy === 'uncapped') {
+        return {
+            ...baseSelection,
+            preferredValue: role === 'reviewer' ? null : preferredValue,
+            selectedValue: role === 'reviewer' ? null : preferredValue,
+            capped: false,
+            selectionMode: role === 'reviewer' ? 'no-review-target' : 'uncapped',
+        };
+    }
+    if (policy.value === null) {
+        return {
+            ...baseSelection,
+            preferredValue: null,
+            selectedValue: null,
+            capped: false,
+            selectionMode: 'capped',
+        };
+    }
     if (role === 'reviewer' || preferredValue === null) {
         return {
-            role,
+            ...baseSelection,
             preferredValue,
-            selectedValue: ceilingValue,
+            selectedValue: policy.value,
             capped: false,
+            selectionMode: role === 'reviewer' ? 'review-target' : 'capped',
         };
     }
     const order = providerValueOrder(provider);
     const preferredIndex = order?.indexOf(preferredValue) ?? -1;
-    const ceilingIndex = order?.indexOf(ceilingValue) ?? -1;
+    const ceilingIndex = order?.indexOf(policy.value) ?? -1;
     if (!order || preferredIndex < 0 || ceilingIndex < 0) {
         return {
-            role,
+            ...baseSelection,
             preferredValue,
-            selectedValue: ceilingValue,
+            selectedValue: policy.value,
             capped: false,
+            selectionMode: 'capped',
         };
     }
     const selectedIndex = Math.min(preferredIndex, ceilingIndex);
     return {
-        role,
+        ...baseSelection,
         preferredValue,
         selectedValue: order[selectedIndex],
         capped: preferredIndex > ceilingIndex,
+        selectionMode: 'capped',
     };
 }
 /**
@@ -233,9 +452,9 @@ function selectDispatchValue(provider, role, ceilingValue, preferredValue) {
  * the enforcement mode, mechanism, dispatch args, and verify-on-upgrade flag.
  * Mode is computed here at call time — it is never read from persisted state.
  */
-function buildProviderResolution(provider, value, role, orchestratorTier, preferredValue) {
+function buildProviderResolution(provider, policy, role, orchestratorTier, preferredValue) {
     const adapter = getCeilingAdapter(provider);
-    if (value === null) {
+    if (policy === null) {
         return {
             value: null,
             mode: adapter.supportsCeiling ? 'advisory' : 'unsupported',
@@ -247,14 +466,19 @@ function buildProviderResolution(provider, value, role, orchestratorTier, prefer
                 preferredValue,
                 selectedValue: null,
                 capped: false,
+                selectionMode: 'unresolved',
+                policyMode: null,
+                policy: null,
             },
         };
     }
-    const selection = selectDispatchValue(provider, role, value, preferredValue);
-    const dispatchValue = selection.selectedValue ?? value;
-    const dispatchArgs = adapter.compileToDispatchArgs(dispatchValue, role, {
-        orchestratorTier,
-    });
+    const selection = selectDispatchValue(provider, role, policy, preferredValue);
+    const dispatchValue = selection.selectedValue;
+    const dispatchArgs = dispatchValue
+        ? adapter.compileToDispatchArgs(dispatchValue, role, {
+            orchestratorTier,
+        })
+        : null;
     let mode;
     if (!adapter.supportsCeiling) {
         mode = 'unsupported';
@@ -266,13 +490,15 @@ function buildProviderResolution(provider, value, role, orchestratorTier, prefer
         mode = 'advisory';
     }
     return {
-        value,
+        value: policy.value,
         mode,
         mechanism: adapter.mechanism,
         dispatchArgs,
-        verifyOnDispatch: adapter.verifyOnDispatch(dispatchValue, {
-            orchestratorTier,
-        }),
+        verifyOnDispatch: dispatchValue
+            ? adapter.verifyOnDispatch(dispatchValue, {
+                orchestratorTier,
+            })
+            : false,
         selection,
     };
 }
@@ -305,7 +531,7 @@ async function resolveCodexProviderDefaultEffort(repoRoot, context, dependencies
 }
 function blockMessage(provider) {
     const label = providerLabel(provider);
-    return `BLOCKED: ${label} dispatch ceiling is unresolved in non-interactive mode.\nSet workflow.dispatchCeiling.providers.${provider} in .oat/config.json or oat_dispatch_ceiling in project state.`;
+    return `BLOCKED: ${label} dispatch policy is unresolved in non-interactive mode.\nSet workflow.dispatchPolicy.mode/workflow.dispatchPolicy.policy, workflow.dispatchCeiling.providers.${provider}, oat_dispatch_policy, or legacy oat_dispatch_ceiling.`;
 }
 function isNonInteractiveEnv(env) {
     return env['OAT_NON_INTERACTIVE'] === '1';
@@ -325,7 +551,7 @@ async function resolveDispatchCeiling(context, dependencies, options) {
         : 'not-applicable';
     const preferredValue = normalizePreferredValue(provider, options.preferred);
     const resolvedValue = await resolveCeilingValue(provider, resolvedConfig, projectPath, dependencies);
-    const providerResolution = buildProviderResolution(provider, resolvedValue?.value ?? null, role, orchestratorTier, preferredValue);
+    const providerResolution = buildProviderResolution(provider, resolvedValue, role, orchestratorTier, preferredValue);
     const providers = {
         [provider]: providerResolution,
     };
@@ -334,6 +560,8 @@ async function resolveDispatchCeiling(context, dependencies, options) {
             status: 'resolved',
             provider,
             value: resolvedValue.value,
+            policyMode: resolvedValue.mode,
+            policy: resolvedValue.policy,
             source: resolvedValue.source,
             preset: resolvedValue.preset,
             unresolved: false,
@@ -350,6 +578,8 @@ async function resolveDispatchCeiling(context, dependencies, options) {
         status: shouldBlock ? 'blocked' : 'unresolved',
         provider,
         value: null,
+        policyMode: null,
+        policy: null,
         source: null,
         preset: null,
         unresolved: true,
@@ -368,37 +598,51 @@ async function resolveDispatchCeiling(context, dependencies, options) {
 async function resolveCeilingValue(provider, resolvedConfig, projectPath, dependencies) {
     const configCeiling = readResolvedConfigCeiling(provider, resolvedConfig);
     if (configCeiling) {
-        return {
-            value: configCeiling.value,
-            source: configCeiling.source,
-            preset: null,
-        };
+        return configCeiling;
     }
     const projectCeiling = await resolveProjectStateCeiling(provider, projectPath, dependencies);
     if (projectCeiling) {
-        return {
-            value: projectCeiling.value,
-            source: 'project-state',
-            preset: projectCeiling.preset,
-        };
+        return projectCeiling;
     }
     return null;
 }
+function policyLabel(policy) {
+    if (policy === 'legacy-ceiling') {
+        return 'legacy capped';
+    }
+    return policy ?? 'inherit host defaults';
+}
 function writeHumanResolution(context, resolution) {
     const label = providerLabel(resolution.provider);
     if (resolution.status === 'blocked' && resolution.message) {
         context.logger.error(resolution.message);
         return;
     }
-    context.logger.info(`${label} dispatch ceiling: ${resolution.value ?? 'unresolved'}`);
+    context.logger.info(`${label} dispatch policy: ${policyLabel(resolution.policy)}`);
+    context.logger.info(`Resolved cap: ${resolution.value ?? 'none'}`);
     context.logger.info(`Source: ${sourceLabel(resolution.source)}`);
     const providerResolution = resolution.providers[resolution.provider];
     if (providerResolution) {
         context.logger.info(`Mode: ${providerResolution.mode} (${providerResolution.mechanism})`);
+        context.logger.info(`Selection: ${providerResolution.selection.selectionMode}`);
     }
     if (resolution.provider === 'codex') {
         context.logger.info(`Codex provider default effort: ${resolution.providerDefaultEffort}`);
-        context.logger.info(`Note: OAT will use pinned subagent variants up to ${resolution.value ?? 'the resolved ceiling'}. Base/unpinned roles resolve through the provider default.`);
+        if (providerResolution?.selection.selectionMode === 'inherit-default') {
+            context.logger.info('Note: OAT will not select a Codex effort; base/unpinned roles resolve through the provider default.');
+        }
+        else if (providerResolution?.selection.selectionMode === 'uncapped') {
+            context.logger.info('Note: OAT will use the preferred pinned Codex variant with no configured cap. Actual host support for upward effort selection must be verified by the dispatching host.');
+        }
+        else if (providerResolution?.selection.selectionMode === 'review-target') {
+            context.logger.info('Note: Reviewer dispatch uses the configured target from the resolved capped policy.');
+        }
+        else if (providerResolution?.selection.selectionMode === 'no-review-target') {
+            context.logger.info('Note: Managed uncapped reviewer dispatch has no configured target; use the base/unpinned reviewer fallback.');
+        }
+        else {
+            context.logger.info(`Note: OAT will use pinned subagent variants up to ${resolution.value ?? 'the resolved policy cap'}. Base/unpinned roles resolve through the provider default.`);
+        }
         if (providerResolution?.selection.selectedValue &&
             providerResolution.selection.preferredValue) {
             context.logger.info(`Selected Codex effort: ${providerResolution.selection.selectedValue}`);
@@ -406,6 +650,9 @@ function writeHumanResolution(context, resolution) {
     }
     else {
         context.logger.info('Effort axis: not-applicable');
+        if (providerResolution?.selection.selectionMode === 'inherit-default') {
+            context.logger.info('Note: OAT will not select a Claude model; Task dispatch inherits host/provider behavior.');
+        }
         if (providerResolution?.selection.selectedValue &&
             providerResolution.selection.preferredValue) {
             context.logger.info(`Selected dispatch value: ${providerResolution.selection.selectedValue}`);
@@ -441,12 +688,12 @@ export function createProjectDispatchCeilingCommand(overrides = {}) {
     };
     const command = new Command('dispatch-ceiling').description('Resolve OAT project dispatch ceiling metadata');
     command.addCommand(new Command('resolve')
-        .description('Resolve dispatch ceiling for a provider')
+        .description('Resolve dispatch policy for a provider')
         .requiredOption('--provider <provider>', 'Provider name: codex or claude are enforced; any other provider resolves as advisory (unsupported)')
         .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 capping by the resolved ceiling')
-        .option('--project-path <path>', 'Read project-state ceiling from an explicit project path')
+        .option('--preferred <value>', 'Preferred implementer/fix dispatch value before applying the resolved policy')
+        .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')
         .option('--json', 'Output machine-readable JSON')

package/dist/config/dispatch-ceiling-preset.d.ts

@@ -1,4 +1,4 @@
-import type { WorkflowClaudeDispatchCeiling, WorkflowCodexDispatchCeiling, WorkflowDispatchCeiling, WorkflowDispatchCeilingPreset } from './oat-config.js';
+import type { WorkflowClaudeDispatchCeiling, WorkflowCodexDispatchCeiling, WorkflowDispatchCeiling, WorkflowDispatchCeilingPreset, WorkflowManagedDispatchPolicy } from './oat-config.js';
 /**
  * Fixed mapping table: preset → concrete per-provider values.
  * This is the single authority for preset compilation; the resolver and skills
@@ -22,6 +22,26 @@ export declare const DISPATCH_CEILING_PRESETS: {
         readonly claude: "sonnet";
     };
 };
+export type DispatchPolicyClaudeValue = WorkflowClaudeDispatchCeiling | 'fable';
+export type CappedManagedDispatchPolicy = Exclude<WorkflowManagedDispatchPolicy, 'uncapped'>;
+export declare const DISPATCH_POLICY_PRESETS: {
+    readonly economy: {
+        readonly codex: "medium";
+        readonly claude: "sonnet";
+    };
+    readonly balanced: {
+        readonly codex: "high";
+        readonly claude: "sonnet";
+    };
+    readonly high: {
+        readonly codex: "xhigh";
+        readonly claude: "opus";
+    };
+    readonly frontier: {
+        readonly codex: "xhigh";
+        readonly claude: "fable";
+    };
+};
 /**
  * Result of compiling a preset selection.
  * Both `preset` (provenance label) and `providers` (concrete values) are present.
@@ -40,6 +60,17 @@ export interface PresetCompileResult {
 export interface AdvancedCompileResult {
     providers: WorkflowDispatchCeiling['providers'] & object;
 }
+export type DispatchPolicyCompileResult = {
+    mode: 'managed';
+    policy: CappedManagedDispatchPolicy;
+    providers: {
+        codex: WorkflowCodexDispatchCeiling;
+        claude: DispatchPolicyClaudeValue;
+    };
+} | {
+    mode: 'managed';
+    policy: 'uncapped';
+};
 /**
  * Compile a preset label into concrete per-provider values.
  * The returned `preset` field is provenance only; runtime dispatch reads
@@ -51,4 +82,9 @@ export declare function compileDispatchCeilingPreset(preset: WorkflowDispatchCei
  * Advanced selections do not set a preset so the persisted shape omits it.
  */
 export declare function compileAdvancedDispatchCeiling(providers: WorkflowDispatchCeiling['providers'] & object): AdvancedCompileResult;
+/**
+ * Compile the managed dispatch-policy ladder into concrete provider caps.
+ * `uncapped` is intentionally explicit but has no provider caps.
+ */
+export declare function compileDispatchPolicyPreset(policy: WorkflowManagedDispatchPolicy): DispatchPolicyCompileResult;
 //# sourceMappingURL=dispatch-ceiling-preset.d.ts.map

package/dist/config/dispatch-ceiling-preset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch-ceiling-preset.d.ts","sourceRoot":"","sources":["../../src/config/dispatch-ceiling-preset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,6BAA6B,EAC7B,4BAA4B,EAC5B,uBAAuB,EACvB,6BAA6B,EAC9B,MAAM,cAAc,CAAC;AAEtB;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;CAOpC,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,6BAA6B,CAAC;IACtC,SAAS,EAAE;QACT,KAAK,EAAE,4BAA4B,CAAC;QACpC,MAAM,EAAE,6BAA6B,CAAC;KACvC,CAAC;CACH;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,uBAAuB,CAAC,WAAW,CAAC,GAAG,MAAM,CAAC;CAC1D;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,6BAA6B,GACpC,mBAAmB,CAKrB;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,uBAAuB,CAAC,WAAW,CAAC,GAAG,MAAM,GACvD,qBAAqB,CAEvB"}
+{"version":3,"file":"dispatch-ceiling-preset.d.ts","sourceRoot":"","sources":["../../src/config/dispatch-ceiling-preset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,6BAA6B,EAC7B,4BAA4B,EAC5B,uBAAuB,EACvB,6BAA6B,EAC7B,6BAA6B,EAC9B,MAAM,cAAc,CAAC;AAEtB;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;CAOpC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,6BAA6B,GAAG,OAAO,CAAC;AAChF,MAAM,MAAM,2BAA2B,GAAG,OAAO,CAC/C,6BAA6B,EAC7B,UAAU,CACX,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;CAQnC,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,6BAA6B,CAAC;IACtC,SAAS,EAAE;QACT,KAAK,EAAE,4BAA4B,CAAC;QACpC,MAAM,EAAE,6BAA6B,CAAC;KACvC,CAAC;CACH;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,uBAAuB,CAAC,WAAW,CAAC,GAAG,MAAM,CAAC;CAC1D;AAED,MAAM,MAAM,2BAA2B,GACnC;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,2BAA2B,CAAC;IACpC,SAAS,EAAE;QACT,KAAK,EAAE,4BAA4B,CAAC;QACpC,MAAM,EAAE,yBAAyB,CAAC;KACnC,CAAC;CACH,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAEN;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,6BAA6B,GACpC,mBAAmB,CAKrB;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,uBAAuB,CAAC,WAAW,CAAC,GAAG,MAAM,GACvD,qBAAqB,CAEvB;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,6BAA6B,GACpC,2BAA2B,CAU7B"}

package/dist/config/dispatch-ceiling-preset.js

@@ -12,6 +12,12 @@ export const DISPATCH_CEILING_PRESETS = {
     maximum: { codex: 'xhigh', claude: 'opus' },
     'cost-conscious': { codex: 'medium', claude: 'sonnet' },
 };
+export const DISPATCH_POLICY_PRESETS = {
+    economy: { codex: 'medium', claude: 'sonnet' },
+    balanced: { codex: 'high', claude: 'sonnet' },
+    high: { codex: 'xhigh', claude: 'opus' },
+    frontier: { codex: 'xhigh', claude: 'fable' },
+};
 /**
  * Compile a preset label into concrete per-provider values.
  * The returned `preset` field is provenance only; runtime dispatch reads
@@ -30,3 +36,17 @@ export function compileDispatchCeilingPreset(preset) {
 export function compileAdvancedDispatchCeiling(providers) {
     return { providers };
 }
+/**
+ * Compile the managed dispatch-policy ladder into concrete provider caps.
+ * `uncapped` is intentionally explicit but has no provider caps.
+ */
+export function compileDispatchPolicyPreset(policy) {
+    if (policy === 'uncapped') {
+        return { mode: 'managed', policy };
+    }
+    return {
+        mode: 'managed',
+        policy,
+        providers: { ...DISPATCH_POLICY_PRESETS[policy] },
+    };
+}

package/dist/config/oat-config.d.ts

@@ -21,8 +21,10 @@ export type WorkflowPostImplementSequence = 'wait' | 'summary' | 'pr' | 'docs-pr
 export type WorkflowReviewExecutionModel = 'subagent' | 'inline' | 'fresh-session';
 export type WorkflowDesignMode = 'collaborative' | 'selective' | 'draft';
 export type WorkflowCodexDispatchCeiling = 'low' | 'medium' | 'high' | 'xhigh';
-export type WorkflowClaudeDispatchCeiling = 'haiku' | 'sonnet' | 'opus';
+export type WorkflowClaudeDispatchCeiling = 'haiku' | 'sonnet' | 'opus' | 'fable';
 export type WorkflowDispatchCeilingPreset = 'balanced' | 'maximum' | 'cost-conscious';
+export type WorkflowDispatchPolicyMode = 'managed' | 'inherit';
+export type WorkflowManagedDispatchPolicy = 'economy' | 'balanced' | 'high' | 'frontier' | 'uncapped';
 export type GateOnFailure = 'block' | 'prompt' | 'warn';
 export type GateAvoid = 'same-runtime' | 'none';
 export interface WorkflowDispatchCeiling {
@@ -32,6 +34,10 @@ export interface WorkflowDispatchCeiling {
         claude?: WorkflowClaudeDispatchCeiling;
     };
 }
+export interface WorkflowDispatchPolicy {
+    mode: WorkflowDispatchPolicyMode;
+    policy?: WorkflowManagedDispatchPolicy;
+}
 export interface WorkflowAutoArtifactReview {
     plan?: boolean;
     analysis?: boolean;
@@ -64,12 +70,15 @@ export interface OatWorkflowConfig {
     autoNarrowReReviewScope?: boolean;
     autoArtifactReview?: WorkflowAutoArtifactReview;
     designMode?: WorkflowDesignMode;
+    dispatchPolicy?: WorkflowDispatchPolicy;
     dispatchCeiling?: WorkflowDispatchCeiling;
     gates?: WorkflowGatesConfig;
 }
 export declare const VALID_CODEX_DISPATCH_CEILINGS: readonly WorkflowCodexDispatchCeiling[];
 export declare const VALID_CLAUDE_DISPATCH_CEILINGS: readonly WorkflowClaudeDispatchCeiling[];
 export declare const VALID_DISPATCH_CEILING_PRESETS: readonly WorkflowDispatchCeilingPreset[];
+export declare const VALID_DISPATCH_POLICY_MODES: readonly WorkflowDispatchPolicyMode[];
+export declare const VALID_MANAGED_DISPATCH_POLICIES: readonly WorkflowManagedDispatchPolicy[];
 export declare const BUILTIN_EXEC_TARGETS: Readonly<Record<string, ExecTarget>>;
 export type OatToolsConfig = Partial<Record<'core' | 'ideas' | 'docs' | 'workflows' | 'utility' | 'project-management' | 'research' | 'brainstorm', boolean>>;
 export interface OatConfig {