@open-agent-toolkit/cli 0.1.43 → 0.1.46

package/dist/providers/codex/codec/sync-extension.js

@@ -1,14 +1,17 @@
 import { createHash } from 'node:crypto';
-import { readFile, rm, writeFile } from 'node:fs/promises';
-import { dirname, join, relative, resolve } from 'node:path';
+import { readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, join, relative, resolve } from 'node:path';
 import { parseCanonicalAgentFile } from '../../../agents/canonical/index.js';
+import { isCodexMaterializedRouteTarget, resolveActiveProject, validateDispatchRouteTarget, } from '../../../config/oat-config.js';
+import { resolveEffectiveConfig } from '../../../config/resolve.js';
 import { ensureDir, fileExists } from '../../../fs/io.js';
 import TOML from '@iarna/toml';
+import YAML from 'yaml';
 import { mergeCodexConfig } from './config-merge.js';
 import { exportCanonicalAgentToCodexRole } from './export-to-codex.js';
+import { materializeCodexRole } from './materialize.js';
 import { isOatManagedCodexRoleFile } from './shared.js';
-const CODEX_EFFORT_VARIANTS = ['low', 'medium', 'high', 'xhigh'];
-const CODEX_EFFORT_VARIANT_BASE_ROLES = new Set([
+const CODEX_MATERIALIZED_BASE_ROLES = new Set([
     'oat-phase-implementer',
     'oat-reviewer',
 ]);
@@ -42,41 +45,7 @@ function normalizeManagedRolesConfig(desiredRoles) {
         configFile: role.configFile,
     }));
 }
-function codexEffortVariantContent(baseContent, baseRoleName, variantRoleName, effort) {
-    return baseContent
-        .replace(`# oat-role: ${baseRoleName}`, `# oat-role: ${variantRoleName}`)
-        .replace('developer_instructions =', `model_reasoning_effort = "${effort}"\ndeveloper_instructions =`);
-}
-function codexEffortVariantDescription(baseRoleName, effort) {
-    const roleLabel = baseRoleName === 'oat-reviewer' ? 'reviewer' : 'phase implementer';
-    if (effort === 'low') {
-        return `OAT ${roleLabel} pinned to low reasoning effort for narrow mechanical implementation, fix, or review phases.`;
-    }
-    if (effort === 'medium') {
-        return `OAT ${roleLabel} pinned to medium reasoning effort for normal multi-file implementation, fix, or review phases.`;
-    }
-    if (effort === 'high') {
-        return `OAT ${roleLabel} pinned to high reasoning effort for broad, subtle, or higher-risk implementation, fix, or review phases.`;
-    }
-    return `OAT ${roleLabel} pinned to xhigh reasoning effort for the highest configured Codex dispatch policy cap.`;
-}
-function codexEffortVariantsFromBase(exported) {
-    if (!CODEX_EFFORT_VARIANT_BASE_ROLES.has(exported.roleName)) {
-        return [];
-    }
-    return CODEX_EFFORT_VARIANTS.map((effort) => {
-        const variantRoleName = `${exported.roleName}-${effort}`;
-        const configFile = `agents/${variantRoleName}.toml`;
-        return {
-            roleName: variantRoleName,
-            description: codexEffortVariantDescription(exported.roleName, effort),
-            configFile,
-            rolePath: join(dirname(exported.rolePath), `${variantRoleName}.toml`),
-            content: codexEffortVariantContent(exported.content, exported.roleName, variantRoleName, effort),
-        };
-    });
-}
-async function desiredRolesFromCanonical(canonicalEntries, scopeRoot) {
+async function desiredRolesFromCanonical(canonicalEntries, scopeRoot, materializationTargets) {
     const roles = [];
     for (const entry of canonicalEntries) {
         if (entry.type !== 'agent' ||
@@ -93,10 +62,154 @@ async function desiredRolesFromCanonical(canonicalEntries, scopeRoot) {
             rolePath: join(scopeRoot, '.codex', exported.configFile),
             content: exported.content,
         });
-        roles.push(...codexEffortVariantsFromBase(roles[roles.length - 1]));
+        if (CODEX_MATERIALIZED_BASE_ROLES.has(exported.roleName)) {
+            for (const target of materializationTargets) {
+                const materialized = materializeCodexRole({
+                    agent: parsed,
+                    model: target.model,
+                    effort: target.effort,
+                });
+                roles.push({
+                    roleName: materialized.roleName,
+                    description: materialized.description,
+                    configFile: materialized.configFile,
+                    rolePath: join(scopeRoot, '.codex', materialized.configFile),
+                    content: materialized.content,
+                });
+            }
+        }
     }
     return roles.sort((left, right) => left.roleName.localeCompare(right.roleName));
 }
+function collectCodexTargetFromEntry(entry, targets) {
+    if (typeof entry === 'string') {
+        return;
+    }
+    if (!isCodexMaterializedRouteTarget('codex', entry)) {
+        return;
+    }
+    const validation = validateDispatchRouteTarget('codex', entry);
+    if (!validation.valid || !entry.model || !entry.effort) {
+        return;
+    }
+    targets.set(`${entry.model}\0${entry.effort}`, {
+        model: entry.model,
+        effort: entry.effort,
+    });
+}
+function collectCodexTargetsFromCell(cell, targets) {
+    if (typeof cell === 'string') {
+        return;
+    }
+    for (const entry of cell) {
+        collectCodexTargetFromEntry(entry, targets);
+    }
+}
+function collectCodexMaterializationTargetsFromProvider(providerValue, targets) {
+    if (providerValue === undefined || typeof providerValue === 'string') {
+        return;
+    }
+    for (const cell of Object.values(providerValue)) {
+        if (cell !== undefined) {
+            collectCodexTargetsFromCell(cell, targets);
+        }
+    }
+}
+function sortCodexMaterializationTargets(targets) {
+    return [...targets.values()].sort((left, right) => {
+        const modelOrder = left.model.localeCompare(right.model);
+        return modelOrder === 0
+            ? left.effort.localeCompare(right.effort)
+            : modelOrder;
+    });
+}
+function routeTargetFromUnknown(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    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 : null;
+}
+function collectCodexTargetsFromUnknownCell(value, targets) {
+    if (typeof value === 'string' || !Array.isArray(value)) {
+        return;
+    }
+    for (const entry of value) {
+        if (typeof entry === 'string') {
+            continue;
+        }
+        const target = routeTargetFromUnknown(entry);
+        if (target) {
+            collectCodexTargetFromEntry(target, targets);
+        }
+    }
+}
+function collectCodexTargetsFromUnknownProvider(value, targets) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return;
+    }
+    for (const cell of Object.values(value)) {
+        collectCodexTargetsFromUnknownCell(cell, targets);
+    }
+}
+function frontmatterBlock(content) {
+    const normalized = content.startsWith('\uFEFF') ? content.slice(1) : content;
+    if (!normalized.startsWith('---\n')) {
+        return null;
+    }
+    const end = normalized.indexOf('\n---', 4);
+    return end > 0 ? normalized.slice(4, end) : null;
+}
+async function collectProjectStateCodexTargets(scopeRoot, options, targets) {
+    const projectPath = options.projectPath === undefined
+        ? (await resolveActiveProject(scopeRoot)).path
+        : options.projectPath;
+    if (!projectPath) {
+        return;
+    }
+    const statePath = join(resolve(scopeRoot, projectPath), 'state.md');
+    const stateContent = await readOptionalFile(statePath);
+    if (!stateContent) {
+        return;
+    }
+    const frontmatter = frontmatterBlock(stateContent);
+    if (!frontmatter) {
+        return;
+    }
+    const parsed = YAML.parse(frontmatter);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return;
+    }
+    const policy = parsed['oat_dispatch_policy'];
+    if (!policy || typeof policy !== 'object' || Array.isArray(policy)) {
+        return;
+    }
+    const matrix = policy['matrix'];
+    if (!matrix || typeof matrix !== 'object' || Array.isArray(matrix)) {
+        return;
+    }
+    collectCodexTargetsFromUnknownProvider(matrix['codex'], targets);
+}
+async function readCodexMaterializationTargets(scopeRoot, options = {}) {
+    const targets = new Map();
+    const effectiveConfig = await resolveEffectiveConfig(scopeRoot, options.userConfigDir ?? join(scopeRoot, '.oat', '__no-user-config__'), options.env);
+    for (const providerValue of [
+        effectiveConfig.user.workflow?.dispatchCeiling?.providers?.codex,
+        effectiveConfig.shared.workflow?.dispatchCeiling?.providers?.codex,
+        effectiveConfig.local.workflow?.dispatchCeiling?.providers?.codex,
+    ]) {
+        collectCodexMaterializationTargetsFromProvider(providerValue, targets);
+    }
+    await collectProjectStateCodexTargets(scopeRoot, options, targets);
+    return sortCodexMaterializationTargets(targets);
+}
 function parseConfigAgentTable(content) {
     if (!content || content.trim() === '') {
         return {};
@@ -124,7 +237,7 @@ function parseConfigAgentTable(content) {
 }
 async function collectStaleManagedRoles(scopeRoot, existingConfigContent, desiredRoleNames) {
     const agents = parseConfigAgentTable(existingConfigContent);
-    const stale = [];
+    const stale = new Set();
     for (const [roleName, roleConfig] of Object.entries(agents)) {
         if (desiredRoleNames.has(roleName)) {
             continue;
@@ -138,13 +251,37 @@ async function collectStaleManagedRoles(scopeRoot, existingConfigContent, desire
         if (!roleContent || !isOatManagedCodexRoleFile(roleContent, roleName)) {
             continue;
         }
-        stale.push(roleName);
+        stale.add(roleName);
+    }
+    const agentsDir = join(scopeRoot, '.codex', 'agents');
+    let roleFiles;
+    try {
+        roleFiles = await readdir(agentsDir);
+    }
+    catch {
+        roleFiles = [];
+    }
+    for (const roleFile of roleFiles) {
+        if (!roleFile.endsWith('.toml')) {
+            continue;
+        }
+        const roleName = basename(roleFile, '.toml');
+        if (desiredRoleNames.has(roleName) || stale.has(roleName)) {
+            continue;
+        }
+        const rolePath = join(agentsDir, roleFile);
+        const roleContent = await readOptionalFile(rolePath);
+        if (!roleContent || !isOatManagedCodexRoleFile(roleContent, roleName)) {
+            continue;
+        }
+        stale.add(roleName);
     }
-    return stale.sort((left, right) => left.localeCompare(right));
+    return [...stale].sort((left, right) => left.localeCompare(right));
 }
-export async function computeCodexProjectExtensionPlan(scopeRoot, canonicalEntries, allowedCanonicalPaths) {
+export async function computeCodexProjectExtensionPlan(scopeRoot, canonicalEntries, allowedCanonicalPaths, options = {}) {
     const isPartialSync = allowedCanonicalPaths !== undefined && allowedCanonicalPaths.length > 0;
-    const desiredRoles = await desiredRolesFromCanonical(canonicalEntries.filter((entry) => canonicalPathAllowed(scopeRoot, entry, allowedCanonicalPaths)), scopeRoot);
+    const materializationTargets = await readCodexMaterializationTargets(scopeRoot, options);
+    const desiredRoles = await desiredRolesFromCanonical(canonicalEntries.filter((entry) => canonicalPathAllowed(scopeRoot, entry, allowedCanonicalPaths)), scopeRoot, materializationTargets);
     const desiredRoleNames = new Set(desiredRoles.map((role) => role.roleName));
     const existingConfigPath = configPath(scopeRoot);
     const existingConfigContent = await readOptionalFile(existingConfigPath);
@@ -227,7 +364,7 @@ export async function computeCodexProjectExtensionPlan(scopeRoot, canonicalEntri
     });
     return {
         operations,
-        managedRoles: desiredRoles.map((role) => role.roleName),
+        managedRoles: [...desiredRoles.map((role) => role.roleName), ...staleRoles],
         aggregateConfigHash: hashContent(configMerge.mergedContent),
     };
 }

package/dist/providers/identity/availability.d.ts

@@ -0,0 +1,45 @@
+export type MatrixCellAvailability = 'valid' | 'unknown-value' | 'unvalidated';
+export interface MatrixCellAvailabilityResult {
+    availability: MatrixCellAvailability;
+    allowedValues?: string[];
+    message?: string;
+}
+export type MatrixCellAvailabilityResponse = MatrixCellAvailability | MatrixCellAvailabilityResult;
+export interface CursorAgentRunOptions {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export interface CursorAgentRunResult {
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+}
+export interface CodexRunOptions {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export interface CodexRunResult {
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+}
+export interface AvailabilityOracleDependencies {
+    pathExists: (path: string) => Promise<boolean>;
+    runCursorAgent: (args: string[], options: CursorAgentRunOptions) => Promise<CursorAgentRunResult>;
+    runCodex: (args: string[], options: CodexRunOptions) => Promise<CodexRunResult>;
+    env?: NodeJS.ProcessEnv;
+}
+export interface ValidateMatrixCellOptions {
+    cwd: string;
+    detailed?: boolean;
+    env?: NodeJS.ProcessEnv;
+    dependencies?: Partial<AvailabilityOracleDependencies>;
+    target?: {
+        model?: string;
+        effort?: string;
+    } | null;
+}
+export declare function normalizeMatrixCellAvailability(result: MatrixCellAvailabilityResponse): MatrixCellAvailabilityResult;
+export declare function validateCursorSubagentModel(value: string, options: ValidateMatrixCellOptions): Promise<MatrixCellAvailabilityResult>;
+export declare function validateMatrixCell(provider: string, value: string, options: ValidateMatrixCellOptions): Promise<MatrixCellAvailabilityResponse>;
+//# sourceMappingURL=availability.d.ts.map

package/dist/providers/identity/availability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/availability.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,eAAe,GAAG,aAAa,CAAC;AAE/E,MAAM,WAAW,4BAA4B;IAC3C,YAAY,EAAE,sBAAsB,CAAC;IACrC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,8BAA8B,GACtC,sBAAsB,GACtB,4BAA4B,CAAC;AAEjC,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,8BAA8B;IAC7C,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/C,cAAc,EAAE,CACd,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,qBAAqB,KAC3B,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnC,QAAQ,EAAE,CACR,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,eAAe,KACrB,OAAO,CAAC,cAAc,CAAC,CAAC;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC,8BAA8B,CAAC,CAAC;IACvD,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,GAAG,IAAI,CAAC;CACV;AAWD,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,8BAA8B,GACrC,4BAA4B,CAE9B;AA+VD,wBAAsB,2BAA2B,CAC/C,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,4BAA4B,CAAC,CAsEvC;AAED,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,8BAA8B,CAAC,CA2CzC"}

package/dist/providers/identity/availability.js

@@ -0,0 +1,353 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { VALID_CLAUDE_DISPATCH_CEILINGS } from '../../config/oat-config.js';
+import { fileExists } from '../../fs/io.js';
+const execFileAsync = promisify(execFile);
+export function normalizeMatrixCellAvailability(result) {
+    return typeof result === 'string' ? { availability: result } : result;
+}
+async function runCursorAgent(args, options) {
+    try {
+        const { stdout, stderr } = await execFileAsync('cursor-agent', args, {
+            cwd: options.cwd,
+            env: options.env,
+            maxBuffer: 1024 * 1024,
+            timeout: 10_000,
+        });
+        return {
+            ok: true,
+            stdout: String(stdout),
+            stderr: String(stderr),
+        };
+    }
+    catch (error) {
+        const failure = error;
+        return {
+            ok: false,
+            stdout: String(failure.stdout ?? ''),
+            stderr: String(failure.stderr ?? failure.message),
+        };
+    }
+}
+async function runCodex(args, options) {
+    try {
+        const { stdout, stderr } = await execFileAsync('codex', args, {
+            cwd: options.cwd,
+            env: options.env,
+            maxBuffer: 16 * 1024 * 1024,
+            timeout: 10_000,
+        });
+        return {
+            ok: true,
+            stdout: String(stdout),
+            stderr: String(stderr),
+        };
+    }
+    catch (error) {
+        const failure = error;
+        return {
+            ok: false,
+            stdout: String(failure.stdout ?? ''),
+            stderr: String(failure.stderr ?? failure.message),
+        };
+    }
+}
+const DEFAULT_DEPENDENCIES = {
+    pathExists: fileExists,
+    runCursorAgent,
+    runCodex,
+    env: process.env,
+};
+function apiKeyArgs(env) {
+    const apiKey = env.CURSOR_API_KEY;
+    return typeof apiKey === 'string' && apiKey.length > 0
+        ? ['--api-key', apiKey]
+        : [];
+}
+function parseCursorCatalog(stdout) {
+    const entries = [];
+    for (const line of stdout.split(/\r?\n/)) {
+        const match = line.match(/^(\S+)\s+-\s+(.+)$/);
+        if (!match) {
+            continue;
+        }
+        const [, slug] = match;
+        if (slug) {
+            entries.push({ slug });
+        }
+    }
+    return entries;
+}
+function availabilityFromCursorCatalog(value, stdout) {
+    const entries = parseCursorCatalog(stdout);
+    if (entries.length === 0) {
+        return null;
+    }
+    return entries.some((entry) => entry.slug === value)
+        ? 'valid'
+        : 'unknown-value';
+}
+const CURSOR_SUBAGENT_PROBE_SENTINEL = 'OAT_CURSOR_SUBAGENT_MODEL_VALID';
+function hasCursorSubagentProbeSentinel(stdout) {
+    return stdout
+        .split(/\r?\n/)
+        .some((line) => line.trim() === CURSOR_SUBAGENT_PROBE_SENTINEL);
+}
+function cursorSubagentProbePrompt(model) {
+    return [
+        'Validate whether a Cursor subagent Task can be launched with a specific model.',
+        `Use the Task tool once with model "${model}" and ask the subagent to reply exactly: ${CURSOR_SUBAGENT_PROBE_SENTINEL}.`,
+        'After the subagent returns, print only its exact reply.',
+    ].join('\n');
+}
+function cursorSubagentProbeArgs(model, env) {
+    return [
+        ...apiKeyArgs(env),
+        '-p',
+        cursorSubagentProbePrompt(model),
+        '--output-format=text',
+        '--force',
+    ];
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function extractModelSlugs(value) {
+    const matches = value.match(/\b[a-z][a-z0-9]*(?:[-.][a-z0-9]+)+\b/gi) ?? [];
+    return unique(matches
+        .map((match) => match.replace(/[),.;:]+$/g, ''))
+        .filter((match) => /\d/.test(match)));
+}
+function parseCursorAllowedSubagentModels(output) {
+    const sections = [];
+    const patterns = [
+        /\ballowed\s+(?:subagent\s+)?models?\s*:?\s*([^\n]+)/gi,
+        /\bsupported\s+(?:subagent\s+)?models?\s*:?\s*([^\n]+)/gi,
+        /\bvalid\s+(?:subagent\s+)?models?\s*:?\s*([^\n]+)/gi,
+        /\bone\s+of\s*:?\s*([^\n]+)/gi,
+    ];
+    for (const pattern of patterns) {
+        for (const match of output.matchAll(pattern)) {
+            if (match[1]) {
+                sections.push(match[1]);
+            }
+        }
+    }
+    return unique(sections.flatMap(extractModelSlugs));
+}
+function cursorAllowedModelsMessage(allowedValues) {
+    return `Allowed subagent models: ${allowedValues.join(', ')}.`;
+}
+function cursorRejectedMessage(allowedValues) {
+    return `Cursor rejected this model for subagent Task dispatch. ${cursorAllowedModelsMessage(allowedValues)}`;
+}
+function cursorCatalogContextMessage(value, availability) {
+    if (availability === 'valid') {
+        return `Cursor's broad model catalog lists '${value}', but subagent Task dispatch could not be validated.`;
+    }
+    if (availability === 'unknown-value') {
+        return `Cursor's broad model catalog does not list '${value}'.`;
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringFromUnknown(value) {
+    return typeof value === 'string' && value.trim().length > 0
+        ? value.trim()
+        : null;
+}
+function extractCodexEffort(value) {
+    if (typeof value === 'string') {
+        return stringFromUnknown(value);
+    }
+    if (!isRecord(value)) {
+        return null;
+    }
+    return (stringFromUnknown(value.effort) ??
+        stringFromUnknown(value.id) ??
+        stringFromUnknown(value.name));
+}
+function extractCodexEfforts(model) {
+    const efforts = [];
+    for (const key of [
+        'supported_reasoning_levels',
+        'supported_reasoning_efforts',
+        'supported_efforts',
+    ]) {
+        const value = model[key];
+        if (!Array.isArray(value)) {
+            continue;
+        }
+        efforts.push(...value
+            .map(extractCodexEffort)
+            .filter((effort) => effort !== null));
+    }
+    const defaultEffort = stringFromUnknown(model.default_reasoning_level);
+    if (defaultEffort) {
+        efforts.push(defaultEffort);
+    }
+    return unique(efforts);
+}
+function parseCodexCatalog(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(parsed) || !Array.isArray(parsed.models)) {
+        return null;
+    }
+    const entries = [];
+    for (const model of parsed.models) {
+        if (!isRecord(model)) {
+            continue;
+        }
+        const slug = stringFromUnknown(model.slug);
+        if (!slug) {
+            continue;
+        }
+        const supportedEfforts = extractCodexEfforts(model);
+        entries.push({
+            slug,
+            supportedEfforts: supportedEfforts.length > 0 ? supportedEfforts : null,
+        });
+    }
+    return entries.length > 0 ? entries : null;
+}
+function codexTargetFromValue(value, target) {
+    const targetModel = stringFromUnknown(target?.model);
+    const targetEffort = stringFromUnknown(target?.effort);
+    if (targetModel && targetEffort) {
+        return { model: targetModel, effort: targetEffort };
+    }
+    const [model, effort] = value.split('/');
+    return {
+        model: stringFromUnknown(model),
+        effort: stringFromUnknown(effort),
+    };
+}
+function codexUnsupportedEffortMessage(model, effort, supportedEfforts) {
+    return `Codex debug models lists '${model}', but effort '${effort}' is not supported. Supported Codex efforts: ${supportedEfforts.join(', ')}.`;
+}
+async function validateCodexCell(value, cwd, dependencies, target) {
+    const { model, effort } = codexTargetFromValue(value, target);
+    if (!model || !effort || value.trim().length === 0) {
+        return { availability: 'unknown-value' };
+    }
+    const result = await dependencies.runCodex(['debug', 'models'], {
+        cwd,
+        env: dependencies.env ?? process.env,
+    });
+    if (!result.ok) {
+        return { availability: 'unvalidated' };
+    }
+    const catalog = parseCodexCatalog(result.stdout);
+    if (!catalog) {
+        return { availability: 'unvalidated' };
+    }
+    const entry = catalog.find((modelEntry) => modelEntry.slug === model);
+    if (!entry) {
+        return {
+            availability: 'unknown-value',
+            message: `Codex debug models does not list '${model}'.`,
+        };
+    }
+    if (!entry.supportedEfforts) {
+        return {
+            availability: 'unvalidated',
+            message: `Codex debug models lists '${model}', but supported reasoning efforts could not be parsed.`,
+        };
+    }
+    if (!entry.supportedEfforts.includes(effort)) {
+        return {
+            availability: 'unknown-value',
+            allowedValues: entry.supportedEfforts,
+            message: codexUnsupportedEffortMessage(model, effort, entry.supportedEfforts),
+        };
+    }
+    return { availability: 'valid' };
+}
+export async function validateCursorSubagentModel(value, options) {
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        env: options.env ?? DEFAULT_DEPENDENCIES.env,
+        ...options.dependencies,
+    };
+    const env = dependencies.env ?? process.env;
+    const runOptions = { cwd: options.cwd, env };
+    const probeResult = await dependencies.runCursorAgent(cursorSubagentProbeArgs(value, env), runOptions);
+    const probeOutput = `${probeResult.stdout}\n${probeResult.stderr}`;
+    if (probeResult.ok && hasCursorSubagentProbeSentinel(probeResult.stdout)) {
+        return { availability: 'valid' };
+    }
+    const allowedValues = parseCursorAllowedSubagentModels(probeOutput);
+    if (allowedValues.length > 0) {
+        const availability = allowedValues.includes(value)
+            ? 'valid'
+            : 'unknown-value';
+        return {
+            availability,
+            allowedValues,
+            message: availability === 'valid'
+                ? cursorAllowedModelsMessage(allowedValues)
+                : cursorRejectedMessage(allowedValues),
+        };
+    }
+    const modelsResult = await dependencies.runCursorAgent([...apiKeyArgs(env), 'models'], runOptions);
+    if (modelsResult.ok) {
+        const availability = availabilityFromCursorCatalog(value, modelsResult.stdout);
+        if (availability !== null) {
+            return {
+                availability: availability === 'valid' ? 'unvalidated' : 'unknown-value',
+                message: cursorCatalogContextMessage(value, availability),
+            };
+        }
+    }
+    const listResult = await dependencies.runCursorAgent([...apiKeyArgs(env), '--list-models'], runOptions);
+    if (listResult.ok) {
+        const availability = availabilityFromCursorCatalog(value, listResult.stdout);
+        if (availability !== null) {
+            return {
+                availability: availability === 'valid' ? 'unvalidated' : 'unknown-value',
+                message: cursorCatalogContextMessage(value, availability),
+            };
+        }
+    }
+    return { availability: 'unvalidated' };
+}
+export async function validateMatrixCell(provider, value, options) {
+    const normalizedProvider = provider.trim().toLowerCase();
+    const normalizedValue = value.trim();
+    if (!normalizedProvider || !normalizedValue) {
+        return options.detailed
+            ? { availability: 'unknown-value' }
+            : 'unknown-value';
+    }
+    const dependencies = {
+        ...DEFAULT_DEPENDENCIES,
+        env: options.env ?? DEFAULT_DEPENDENCIES.env,
+        ...options.dependencies,
+    };
+    if (normalizedProvider === 'claude') {
+        const availability = VALID_CLAUDE_DISPATCH_CEILINGS.includes(normalizedValue)
+            ? 'valid'
+            : 'unknown-value';
+        return options.detailed ? { availability } : availability;
+    }
+    if (normalizedProvider === 'codex') {
+        const result = await validateCodexCell(normalizedValue, options.cwd, dependencies, options.target);
+        return options.detailed ? result : result.availability;
+    }
+    if (normalizedProvider === 'cursor') {
+        const result = await validateCursorSubagentModel(normalizedValue, {
+            ...options,
+            dependencies,
+        });
+        return options.detailed ? result : result.availability;
+    }
+    return options.detailed ? { availability: 'unvalidated' } : 'unvalidated';
+}