@open-agent-toolkit/cli 0.3.1 → 0.3.2

package/dist/providers/claude/dispatch-envelope.js

@@ -0,0 +1,233 @@
+import { parseGenericDispatchRecord, } from '../identity/generic-dispatch-record.js';
+import YAML from 'yaml';
+import { z } from 'zod';
+import { readOatManagedClaudeRole } from './codec/materialize.js';
+import { buildClaudeEffortVariantName, validateClaudeDispatchCapability, } from './targets.js';
+const generationSchema = z.enum([
+    'fable-5-1',
+    'fable-5',
+    'opus-5-5',
+    'sonnet-5',
+    'opus-4-7',
+    'opus-4-6',
+    'sonnet-4-6',
+]);
+const capabilityEvidenceSchema = z
+    .object({
+    source: z.enum([
+        'explicit-model-id',
+        'family-pin-model-id',
+        'family-pin-declaration',
+        'alias-capability-equivalence',
+    ]),
+    modelReference: z.string().min(1),
+    exactModel: z.boolean(),
+    generation: generationSchema.optional(),
+    possibleGenerations: z.array(generationSchema).optional(),
+    capabilitiesSource: z.string().min(1),
+    supportedEfforts: z.array(z.string().min(1)).min(1),
+})
+    .strict();
+const targetSchema = z
+    .object({
+    model: z.string().min(1),
+    effort: z.string().min(1),
+    capabilityEvidence: capabilityEvidenceSchema,
+    crossHarness: z.literal(false),
+})
+    .passthrough();
+const providerResolutionSchema = z
+    .object({
+    value: z.string().min(1),
+    mode: z.literal('enforced'),
+    mechanism: z.literal('pinned-variant'),
+    dispatchArgs: z.object({ variant: z.string().min(1) }).strict(),
+    modelAxis: z.string().min(1),
+    effortAxis: z.string().min(1),
+    target: targetSchema,
+    selection: z
+        .object({
+        role: z.enum(['implementer', 'reviewer']),
+        policyMode: z.literal('managed'),
+        policy: z.string().min(1),
+        target: targetSchema,
+    })
+        .passthrough(),
+})
+    .passthrough();
+const resolutionSchema = z
+    .object({
+    status: z.literal('resolved'),
+    provider: z.literal('claude'),
+    policyMode: z.literal('managed'),
+    policy: z.string().min(1),
+    providers: z.object({ claude: providerResolutionSchema }).passthrough(),
+})
+    .passthrough();
+const launchPayloadSchema = z
+    .object({
+    variant: z.string().min(1),
+    model: z.string().min(1).optional(),
+})
+    .strict();
+const PROTECTED_RECORD_FIELDS = [
+    'provider',
+    'dispatch_policy',
+    'dispatch_ceiling',
+    'role_name',
+    'role_selector',
+    'model_selector',
+    'model_selector_granularity',
+    'effort_selector',
+    'selection_source',
+    'candidates_considered',
+    'selection_reason',
+    'selected_route',
+    'payload',
+    'configured_invocation_evidence',
+];
+function definitionFrontmatter(content) {
+    const match = /^---\n([\s\S]*?)\n---(?:\n|$)/u.exec(content);
+    if (!match?.[1]) {
+        throw new Error('Generated Claude definition has no YAML frontmatter.');
+    }
+    const parsed = YAML.parse(match[1]);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('Generated Claude definition frontmatter is not a map.');
+    }
+    return parsed;
+}
+function assertSameTarget(left, right) {
+    if (left.model !== right.model ||
+        left.effort !== right.effort ||
+        JSON.stringify(left.capabilityEvidence) !==
+            JSON.stringify(right.capabilityEvidence)) {
+        throw new Error('Claude resolver target and selection target disagree on model, effort, or capability evidence.');
+    }
+}
+/**
+ * Validate the managed resolver result against the generated provider role and
+ * the exact payload that will be launched. This is the production boundary
+ * used by the project dispatch-record producer for managed Claude dispatches.
+ */
+export function acceptClaudeLaunchEnvelope(input) {
+    const resolution = resolutionSchema.parse(input.resolution);
+    const provider = resolution.providers.claude;
+    const launch = launchPayloadSchema.parse(input.launch);
+    assertSameTarget(provider.target, provider.selection.target);
+    const validation = validateClaudeDispatchCapability(provider.selection.target);
+    if (!validation.valid) {
+        throw new Error(validation.reason ?? 'Resolver selected an invalid Claude target.');
+    }
+    const baseRole = provider.selection.role === 'reviewer'
+        ? 'oat-reviewer'
+        : 'oat-phase-implementer';
+    const expectedVariant = buildClaudeEffortVariantName({
+        agentName: baseRole,
+        model: provider.selection.target.model,
+        effort: provider.selection.target.effort,
+    });
+    if (provider.dispatchArgs.variant !== expectedVariant) {
+        throw new Error(`Managed Claude resolver variant ${provider.dispatchArgs.variant} does not match selected target ${expectedVariant}.`);
+    }
+    if (launch.variant !== expectedVariant) {
+        throw new Error(`Claude launch variant ${launch.variant} does not match resolver-selected variant ${expectedVariant}.`);
+    }
+    const managed = readOatManagedClaudeRole(input.definition);
+    if (!managed || managed.roleName !== expectedVariant) {
+        throw new Error(`Generated Claude definition ${expectedVariant} is absent or is not the matching OAT-managed role.`);
+    }
+    if (JSON.stringify(managed.capabilityEvidence) !==
+        JSON.stringify(provider.selection.target.capabilityEvidence)) {
+        throw new Error('Generated Claude definition capability evidence does not match the resolver-selected capability.');
+    }
+    const frontmatter = definitionFrontmatter(input.definition);
+    if (frontmatter.name !== expectedVariant) {
+        throw new Error(`Generated Claude definition name does not match ${expectedVariant}.`);
+    }
+    if (frontmatter.model !== provider.selection.target.model) {
+        throw new Error(`Generated Claude definition model does not match selected model ${provider.selection.target.model}.`);
+    }
+    if (frontmatter.effort !== provider.selection.target.effort) {
+        throw new Error(`Generated Claude definition effort does not match selected effort ${provider.selection.target.effort}.`);
+    }
+    if (launch.model !== undefined &&
+        launch.model !== provider.selection.target.model) {
+        throw new Error(`Per-call Claude model ${launch.model} conflicts with generated definition model ${provider.selection.target.model}.`);
+    }
+    if (provider.modelAxis !== `selected:${provider.selection.target.model}`) {
+        throw new Error('Claude resolver model axis disagrees with its target.');
+    }
+    if (provider.effortAxis !== `selected:${provider.selection.target.effort}`) {
+        throw new Error('Claude resolver effort axis disagrees with its target.');
+    }
+    return {
+        schemaVersion: 1,
+        provider: 'claude',
+        resolverRole: provider.selection.role,
+        baseRole,
+        variant: expectedVariant,
+        model: provider.selection.target.model,
+        capabilityEvidence: provider.selection.target.capabilityEvidence,
+        effort: provider.selection.target.effort,
+        policy: resolution.policy,
+        ceiling: provider.value,
+        payload: launch,
+    };
+}
+function recordBase(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('Managed Claude dispatch recordBase must be a JSON object.');
+    }
+    const base = value;
+    for (const field of PROTECTED_RECORD_FIELDS) {
+        if (Object.hasOwn(base, field)) {
+            throw new Error(`Managed Claude dispatch recordBase must omit derived field ${field}.`);
+        }
+    }
+    return base;
+}
+/** Build configured invocation evidence only from an accepted launch envelope. */
+export function buildClaudeDispatchRecord(input) {
+    const base = recordBase(input.recordBase);
+    const action = base.action;
+    if ((input.envelope.resolverRole === 'reviewer' && action !== 'review') ||
+        (input.envelope.resolverRole === 'implementer' &&
+            action !== 'implementation' &&
+            action !== 'fix')) {
+        throw new Error(`Managed Claude resolver role ${input.envelope.resolverRole} conflicts with record action ${String(action)}.`);
+    }
+    return parseGenericDispatchRecord({
+        ...base,
+        provider: 'claude',
+        dispatch_policy: input.envelope.policy,
+        dispatch_ceiling: input.envelope.ceiling,
+        role_name: input.envelope.baseRole,
+        role_selector: input.envelope.variant,
+        model_selector: input.envelope.model,
+        model_selector_granularity: 'exact-native-model-choice',
+        effort_selector: input.envelope.effort,
+        selection_source: 'policy-resolved',
+        candidates_considered: [input.envelope.variant],
+        selection_reason: 'native-catalog',
+        selected_route: 'native',
+        payload: input.envelope.payload,
+        configured_invocation_evidence: [
+            {
+                source: 'accepted-claude-launch-envelope',
+                schemaVersion: input.envelope.schemaVersion,
+                variant: input.envelope.variant,
+                model: input.envelope.model,
+                capabilitySource: input.envelope.capabilityEvidence.source,
+                capabilityModelReference: input.envelope.capabilityEvidence.modelReference,
+                capabilityExactModel: input.envelope.capabilityEvidence.exactModel,
+                capabilityGeneration: input.envelope.capabilityEvidence.generation ?? null,
+                capabilityPossibleGenerations: input.envelope.capabilityEvidence.possibleGenerations?.join(',') ??
+                    null,
+                capabilityDeclarationSource: input.envelope.capabilityEvidence.capabilitiesSource,
+                capabilitySupportedEfforts: input.envelope.capabilityEvidence.supportedEfforts.join(','),
+                effort: input.envelope.effort,
+            },
+        ],
+    });
+}

package/dist/providers/claude/targets.d.ts

@@ -0,0 +1,48 @@
+export declare const CLAUDE_MODEL_ORDER: readonly ['haiku', 'sonnet', 'opus', 'fable'];
+export declare const CLAUDE_EFFORT_ORDER: readonly ['low', 'medium', 'high', 'xhigh', 'max'];
+declare const CLAUDE_GENERATION_EFFORTS: {
+    readonly 'fable-5-1': readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly 'fable-5': readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly 'opus-5-5': readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly 'sonnet-5': readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly 'opus-4-7': readonly ["low", "medium", "high", "xhigh", "max"];
+    readonly 'opus-4-6': readonly ["low", "medium", "high", "max"];
+    readonly 'sonnet-4-6': readonly ["low", "medium", "high", "max"];
+};
+export type ClaudeModelGeneration = keyof typeof CLAUDE_GENERATION_EFFORTS;
+export type ClaudeCapabilitySource = 'explicit-model-id' | 'family-pin-model-id' | 'family-pin-declaration' | 'alias-capability-equivalence';
+export interface ClaudeCapabilityEvidence {
+    source: ClaudeCapabilitySource;
+    modelReference: string;
+    exactModel: boolean;
+    generation?: ClaudeModelGeneration;
+    possibleGenerations?: ClaudeModelGeneration[];
+    capabilitiesSource: string;
+    supportedEfforts: string[];
+}
+export interface ClaudeDispatchTarget {
+    model: string;
+    effort?: string;
+    capabilityEvidence?: ClaudeCapabilityEvidence;
+}
+export interface ClaudeTargetValidation {
+    valid: boolean;
+    reason?: string;
+    capabilityEvidence?: ClaudeCapabilityEvidence;
+}
+/** Extract a documented effort-capability generation from a provider model ID. */
+export declare function claudeModelGeneration(model: string): ClaudeModelGeneration | null;
+/** Resolve capability evidence without claiming an unobserved exact model. */
+export declare function resolveClaudeCapabilityEvidence(target: Pick<ClaudeDispatchTarget, 'model' | 'capabilityEvidence'>, env?: NodeJS.ProcessEnv): ClaudeTargetValidation;
+export declare function validateClaudeDispatchTarget(target: ClaudeDispatchTarget): ClaudeTargetValidation;
+/** Validate an effort-pinned target against explicit capability evidence. */
+export declare function validateClaudeDispatchCapability(target: ClaudeDispatchTarget, env?: NodeJS.ProcessEnv): ClaudeTargetValidation;
+export declare function normalizeClaudeRoleName(input: string): string;
+export declare function buildClaudeEffortVariantName(options: {
+    agentName: string;
+    model: string;
+    effort: string;
+}): string;
+export declare function claudeTargetRank(target: ClaudeDispatchTarget): [number, number];
+export {};
+//# sourceMappingURL=targets.d.ts.map

package/dist/providers/claude/targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../../../src/providers/claude/targets.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,YAAI,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAU,CAAC;AAEhF,eAAO,MAAM,mBAAmB,YAC9B,KAAK,EACL,QAAQ,EACR,MAAM,EACN,OAAO,EACP,KAAK,CACG,CAAC;AAEX,QAAA,MAAM,yBAAyB;;;;;;;;CAQuB,CAAC;AAGvD,MAAM,MAAM,qBAAqB,GAAG,MAAM,OAAO,yBAAyB,CAAC;AAC3E,MAAM,MAAM,sBAAsB,GAC9B,mBAAmB,GACnB,qBAAqB,GACrB,wBAAwB,GACxB,8BAA8B,CAAC;AAEnC,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,qBAAqB,CAAC;IACnC,mBAAmB,CAAC,EAAE,qBAAqB,EAAE,CAAC;IAC9C,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B;AASD,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,wBAAwB,CAAC;CAC/C;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,wBAAwB,CAAC;CAC/C;AAkBD,kFAAkF;AAClF,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,GACZ,qBAAqB,GAAG,IAAI,CAc9B;AA4ID,8EAA8E;AAC9E,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,IAAI,CAAC,oBAAoB,EAAE,OAAO,GAAG,oBAAoB,CAAC,EAClE,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,sBAAsB,CAgBxB;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,oBAAoB,GAC3B,sBAAsB,CAoBxB;AAED,6EAA6E;AAC7E,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,oBAAoB,EAC5B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,sBAAsB,CAexB;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ7D;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,MAAM,CAeT;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,oBAAoB,GAC3B,CAAC,MAAM,EAAE,MAAM,CAAC,CAQlB"}

package/dist/providers/claude/targets.js

@@ -0,0 +1,228 @@
+export const CLAUDE_MODEL_ORDER = ['haiku', 'sonnet', 'opus', 'fable'];
+export const CLAUDE_EFFORT_ORDER = [
+    'low',
+    'medium',
+    'high',
+    'xhigh',
+    'max',
+];
+const CLAUDE_GENERATION_EFFORTS = {
+    'fable-5-1': CLAUDE_EFFORT_ORDER,
+    'fable-5': CLAUDE_EFFORT_ORDER,
+    'opus-5-5': CLAUDE_EFFORT_ORDER,
+    'sonnet-5': CLAUDE_EFFORT_ORDER,
+    'opus-4-7': CLAUDE_EFFORT_ORDER,
+    'opus-4-6': ['low', 'medium', 'high', 'max'],
+    'sonnet-4-6': ['low', 'medium', 'high', 'max'],
+};
+const ALIAS_DEFAULT_ENV = {
+    haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+    sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    fable: 'ANTHROPIC_DEFAULT_FABLE_MODEL',
+};
+function modelFamily(model) {
+    const normalized = model.toLowerCase().replace(/\[1m\]$/u, '');
+    for (const family of CLAUDE_MODEL_ORDER) {
+        if (normalized === family ||
+            new RegExp(`(?:^|[./:_-])claude-${family}(?:-|$)`, 'u').test(normalized) ||
+            new RegExp(`(?:^|[./:_-])${family}(?:-|$)`, 'u').test(normalized)) {
+            return family;
+        }
+    }
+    return null;
+}
+/** Extract a documented effort-capability generation from a provider model ID. */
+export function claudeModelGeneration(model) {
+    const normalized = model.toLowerCase().replace(/\[1m\]$/u, '');
+    for (const generation of Object.keys(CLAUDE_GENERATION_EFFORTS)) {
+        const [family, ...versionParts] = generation.split('-');
+        const version = versionParts.join('[-.]');
+        const pattern = new RegExp(`(?:^|[./:_-])(?:claude-)?${family}-${version}(?=$|[-@.:/[])`, 'u');
+        if (pattern.test(normalized))
+            return generation;
+    }
+    return null;
+}
+function generationEvidence(generation, source, modelReference, capabilitiesSource) {
+    return {
+        source,
+        modelReference,
+        exactModel: source === 'explicit-model-id',
+        generation,
+        capabilitiesSource,
+        supportedEfforts: [...CLAUDE_GENERATION_EFFORTS[generation]],
+    };
+}
+function familyPinCapabilityEvidence(family, pinName, pinnedModel, env) {
+    const generation = claudeModelGeneration(pinnedModel);
+    if (generation && modelFamily(generation) !== family) {
+        return {
+            valid: false,
+            reason: `Claude alias ${JSON.stringify(family)} is pinned by ${pinName}=${JSON.stringify(pinnedModel)}, but the pin belongs to another model family.`,
+        };
+    }
+    const capabilityName = `${pinName}_SUPPORTED_CAPABILITIES`;
+    const declaration = env[capabilityName];
+    if (!declaration && generation) {
+        return {
+            valid: true,
+            capabilityEvidence: generationEvidence(generation, 'family-pin-model-id', pinnedModel, pinName),
+        };
+    }
+    if (!declaration) {
+        return {
+            valid: false,
+            reason: `Claude alias ${JSON.stringify(family)} uses custom pin ${pinName}=${JSON.stringify(pinnedModel)}, but ${capabilityName} does not establish effort support.`,
+        };
+    }
+    const capabilities = new Set(declaration
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter(Boolean));
+    if (!capabilities.has('effort')) {
+        return {
+            valid: false,
+            reason: `${capabilityName} must include effort before xhigh_effort or max_effort can establish Claude effort support.`,
+        };
+    }
+    const supportedEfforts = ['low', 'medium', 'high'];
+    if (capabilities.has('xhigh_effort'))
+        supportedEfforts.push('xhigh');
+    if (capabilities.has('max_effort'))
+        supportedEfforts.push('max');
+    return {
+        valid: true,
+        capabilityEvidence: {
+            source: 'family-pin-declaration',
+            modelReference: pinnedModel,
+            exactModel: false,
+            ...(generation ? { generation } : {}),
+            capabilitiesSource: capabilityName,
+            supportedEfforts,
+        },
+    };
+}
+/** Resolve capability evidence without claiming an unobserved exact model. */
+function deriveClaudeCapabilityEvidence(model, env = process.env) {
+    const requestedFamily = modelFamily(model);
+    if (!requestedFamily) {
+        return {
+            valid: false,
+            reason: `Unsupported Claude model ${JSON.stringify(model)}. Valid aliases: ${CLAUDE_MODEL_ORDER.join(', ')}; version-pinned Claude model IDs are also accepted.`,
+        };
+    }
+    const explicitGeneration = claudeModelGeneration(model);
+    if (explicitGeneration) {
+        return {
+            valid: true,
+            capabilityEvidence: generationEvidence(explicitGeneration, 'explicit-model-id', model, 'dispatch-target-model'),
+        };
+    }
+    const alias = model.toLowerCase().replace(/\[1m\]$/u, '');
+    if (alias !== requestedFamily) {
+        return {
+            valid: false,
+            reason: `Cannot establish a documented Claude effort capability for model ${JSON.stringify(model)}. Use a recognized versioned model ID.`,
+        };
+    }
+    const pinName = ALIAS_DEFAULT_ENV[requestedFamily];
+    if (env['CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST']) {
+        return {
+            valid: false,
+            reason: `Claude alias ${JSON.stringify(alias)} has a host-managed provider-dependent generation. Host-managed model configuration takes precedence over ${pinName}; use a versioned model ID in the dispatch target to establish capability.`,
+        };
+    }
+    const pinnedModel = env[pinName];
+    if (pinnedModel) {
+        return familyPinCapabilityEvidence(requestedFamily, pinName, pinnedModel, env);
+    }
+    return {
+        valid: false,
+        reason: `Claude effort-pinned alias ${JSON.stringify(alias)} cannot establish capability because provider routing, availableModels, or organization policy may substitute another generation. Use a recognized versioned model ID or pin ${pinName} with matching capability evidence.`,
+    };
+}
+/** Resolve capability evidence without claiming an unobserved exact model. */
+export function resolveClaudeCapabilityEvidence(target, env = process.env) {
+    const derived = deriveClaudeCapabilityEvidence(target.model, env);
+    if (!derived.valid || !derived.capabilityEvidence)
+        return derived;
+    if (target.capabilityEvidence &&
+        JSON.stringify(target.capabilityEvidence) !==
+            JSON.stringify(derived.capabilityEvidence)) {
+        return {
+            valid: false,
+            reason: 'Provided Claude capability evidence does not match the capability derived from the model and active provider configuration.',
+            capabilityEvidence: derived.capabilityEvidence,
+        };
+    }
+    return derived;
+}
+export function validateClaudeDispatchTarget(target) {
+    if (!modelFamily(target.model)) {
+        return {
+            valid: false,
+            reason: `Unsupported Claude model ${JSON.stringify(target.model)}. Valid aliases: ${CLAUDE_MODEL_ORDER.join(', ')}; version-pinned Claude model IDs are also accepted.`,
+        };
+    }
+    if (target.effort === undefined) {
+        return { valid: true };
+    }
+    if (!CLAUDE_EFFORT_ORDER.includes(target.effort)) {
+        return {
+            valid: false,
+            reason: `Unsupported Claude effort ${JSON.stringify(target.effort)}. Valid values: ${CLAUDE_EFFORT_ORDER.join(', ')}.`,
+        };
+    }
+    return { valid: true };
+}
+/** Validate an effort-pinned target against explicit capability evidence. */
+export function validateClaudeDispatchCapability(target, env = process.env) {
+    const route = validateClaudeDispatchTarget(target);
+    if (!route.valid || target.effort === undefined)
+        return route;
+    const resolution = resolveClaudeCapabilityEvidence(target, env);
+    if (!resolution.valid || !resolution.capabilityEvidence)
+        return resolution;
+    const evidence = resolution.capabilityEvidence;
+    if (!evidence.supportedEfforts.includes(target.effort)) {
+        return {
+            valid: false,
+            reason: `Claude capability evidence ${JSON.stringify(evidence.modelReference)} does not support effort ${JSON.stringify(target.effort)}. Supported values: ${evidence.supportedEfforts.join(', ')}.`,
+            capabilityEvidence: evidence,
+        };
+    }
+    return { valid: true, capabilityEvidence: evidence };
+}
+export function normalizeClaudeRoleName(input) {
+    return input
+        .trim()
+        .toLowerCase()
+        .replace(/\.md$/i, '')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+export function buildClaudeEffortVariantName(options) {
+    const validation = validateClaudeDispatchTarget({
+        model: options.model,
+        effort: options.effort,
+    });
+    if (!validation.valid) {
+        throw new Error(validation.reason);
+    }
+    const agentName = normalizeClaudeRoleName(options.agentName);
+    if (!agentName) {
+        throw new Error('Cannot build Claude effort variant: missing agent name.');
+    }
+    return `${agentName}-claude-${normalizeClaudeRoleName(options.model)}-${options.effort}`;
+}
+export function claudeTargetRank(target) {
+    const family = modelFamily(target.model);
+    return [
+        family ? CLAUDE_MODEL_ORDER.indexOf(family) : -1,
+        target.effort === undefined
+            ? -1
+            : CLAUDE_EFFORT_ORDER.indexOf(target.effort),
+    ];
+}

package/dist/providers/codex/codec/shared.d.ts

@@ -3,6 +3,12 @@ export declare const OAT_MANAGED_ROLE_NAME_PREFIX = "# oat-role: ";
 export declare const OAT_MANAGED_ROLE_OWNER_PREFIX = "# oat-owner: ";
 export type CodexRoleOwner = 'supported-catalogue' | 'user-config' | 'project-config';
 export declare const SUPPORTED_CODEX_ROLE_TARGETS: readonly ({
+    model: string;
+    effort: string;
+} | {
+    model: string;
+    effort: string;
+} | {
     model: string;
     effort: "high" | "low" | "medium" | "xhigh";
 } | {

package/dist/providers/codex/codec/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/providers/codex/codec/shared.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAC7D,eAAO,MAAM,4BAA4B,iBAAiB,CAAC;AAC3D,eAAO,MAAM,6BAA6B,kBAAkB,CAAC;AAE7D,MAAM,MAAM,cAAc,GACtB,qBAAqB,GACrB,aAAa,GACb,gBAAgB,CAAC;AAoBrB,eAAO,MAAM,4BAA4B;;;;;;;;;IAa/B,CAAC;AAEX,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO5D;AAQD,wBAAgB,oCAAoC,CAAC,OAAO,EAAE;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,MAAM,CAiBT;AAgDD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAOT;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,MAAM,CAER;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,GACd,cAAc,GAAG,IAAI,CAEvB;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,cAAc,GACpB,MAAM,CAkBR;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAErE"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/providers/codex/codec/shared.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,uBAAuB,wBAAwB,CAAC;AAC7D,eAAO,MAAM,4BAA4B,iBAAiB,CAAC;AAC3D,eAAO,MAAM,6BAA6B,kBAAkB,CAAC;AAE7D,MAAM,MAAM,cAAc,GACtB,qBAAqB,GACrB,aAAa,GACb,gBAAgB,CAAC;AAoBrB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;IAqB/B,CAAC;AAEX,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO5D;AAQD,wBAAgB,oCAAoC,CAAC,OAAO,EAAE;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,MAAM,CAiBT;AAgDD,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAOT;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,MAAM,CAER;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,GACd,cAAc,GAAG,IAAI,CAEvB;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,cAAc,GACpB,MAAM,CAkBR;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAErE"}

package/dist/providers/codex/codec/shared.js

@@ -12,6 +12,14 @@ const STANDARD_SUPPORTED_CODEX_EFFORTS = [
     'xhigh',
 ];
 export const SUPPORTED_CODEX_ROLE_TARGETS = [
+    ...[...STANDARD_SUPPORTED_CODEX_EFFORTS, 'max'].map((effort) => ({
+        model: 'gpt-6-luna',
+        effort,
+    })),
+    ...[...STANDARD_SUPPORTED_CODEX_EFFORTS, 'max'].map((effort) => ({
+        model: 'gpt-6-sol',
+        effort,
+    })),
     ...STANDARD_SUPPORTED_CODEX_EFFORTS.map((effort) => ({
         model: 'gpt-5.6-luna',
         effort,

package/dist/providers/cursor/codec/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../../src/providers/cursor/codec/catalog.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAC7B,eAAe,GACf,eAAe,GACf,eAAe,GACf,kBAAkB,CAAC;AAEvB;;;;;;;;;;GAUG;AACH,MAAM,WAAW,oBAAoB;IACnC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,KAAK,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,UAAU,CAAC;IACxB,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACpC;AAED,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,qBAAqB,CAAC;IACpC,YAAY,EAAE,qBAAqB,CAAC;IACpC,SAAS,EAAE,OAAO,CAAC;CACpB;AAqCD,eAAO,MAAM,yBAAyB,8eAyJe,CAAC;AAEtD,eAAO,MAAM,6BAA6B,yBAEzC,CAAC;AAEF,eAAO,MAAM,2BAA2B,YACtC,uBAAuB,EACvB,cAAc,CACN,CAAC;AAEX,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,GACpB,qBAAqB,GAAG,SAAS,CAInC"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../../src/providers/cursor/codec/catalog.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAC7B,eAAe,GACf,eAAe,GACf,eAAe,GACf,kBAAkB,CAAC;AAEvB;;;;;;;;;;GAUG;AACH,MAAM,WAAW,oBAAoB;IACnC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,KAAK,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,UAAU,CAAC;IACxB,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACpC;AAED,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,qBAAqB,CAAC;IACpC,YAAY,EAAE,qBAAqB,CAAC;IACpC,SAAS,EAAE,OAAO,CAAC;CACpB;AA+BD,eAAO,MAAM,yBAAyB,8eAsKe,CAAC;AAEtD,eAAO,MAAM,6BAA6B,yBAEzC,CAAC;AAEF,eAAO,MAAM,2BAA2B,YACtC,uBAAuB,EACvB,cAAc,CACN,CAAC;AAEX,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,MAAM,GACpB,qBAAqB,GAAG,SAAS,CAInC"}