@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

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

@@ -0,0 +1,73 @@
+import { readAiwgConfig } from '../config/aiwg-config.js';
+import { normalizeProviderDefinitionId } from '../providers/provider-definitions.js';
+import { collectProviderInventory } from '../providers/provider-inventory.js';
+import { resolveDynamicModelCatalog } from './model-discovery.js';
+export const MODEL_WRAPPERS = {
+    reasoning: 'aiwg-model-reasoning-worker',
+    coding: 'aiwg-model-coding-worker',
+    efficiency: 'aiwg-model-efficiency-worker',
+};
+async function configuredProviders(cwd) {
+    try {
+        const config = await readAiwgConfig(cwd);
+        const candidates = [
+            ...(config?.providers ?? []),
+            ...Object.values(config?.installed ?? {}).flatMap(entry => Object.keys(entry.deployedTo ?? {})),
+        ];
+        return [...new Set(candidates
+                .map(provider => normalizeProviderDefinitionId(provider))
+                .filter((provider) => provider !== null))];
+    }
+    catch {
+        return [];
+    }
+}
+export async function loadProviderModelMetadata(cwd, aiwgRoot) {
+    if (!aiwgRoot)
+        return null;
+    let catalog;
+    let inventory;
+    try {
+        inventory = await collectProviderInventory(cwd, { detectProcess: false });
+        catalog = await resolveDynamicModelCatalog({
+            aiwgRoot,
+            inventory,
+            allowNetwork: false,
+        });
+    }
+    catch {
+        return null;
+    }
+    const configured = await configuredProviders(cwd);
+    const installed = inventory.providers
+        .filter(provider => provider.available || provider.deployed)
+        .map(provider => provider.id)
+        .filter(provider => configured.includes(provider));
+    const providers = {};
+    for (const provider of installed) {
+        const roles = catalog.providers[provider]?.roles;
+        if (!roles)
+            continue;
+        providers[provider] = Object.keys(MODEL_WRAPPERS)
+            .flatMap(role => {
+            const model = roles[role];
+            return model ? [{
+                    provider,
+                    role,
+                    model: model.id,
+                    wrapper: MODEL_WRAPPERS[role],
+                    status: model.status ?? 'unknown',
+                    observed: model.observed ?? false,
+                    source: catalog.discovery?.providers?.[provider]?.source
+                        ?? catalog.discovery?.source
+                        ?? 'static',
+                }] : [];
+        });
+    }
+    return {
+        catalogVersion: catalog.version,
+        refreshedAt: catalog.refreshedAt ?? null,
+        providers,
+    };
+}
+//# sourceMappingURL=provider-models.js.map

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

@@ -0,0 +1,273 @@
+/**
+ * Provider-aware model policy registry, validation, and compilation.
+ * @implements #1802
+ * @implements #1805
+ */
+import { z } from 'zod';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+function requireModelResource(filename) {
+    const candidates = [
+        `./${filename}`,
+        `../../agentic/code/providers/${filename}`,
+        `../../../agentic/code/providers/${filename}`,
+    ];
+    for (const candidate of candidates) {
+        try {
+            return require(candidate);
+        }
+        catch (error) {
+            if (error?.code !== 'MODULE_NOT_FOUND')
+                throw error;
+        }
+    }
+    throw new Error(`Model policy resource is missing: ${filename}`);
+}
+const capabilityData = requireModelResource('model-capabilities.v1.json');
+const catalogData = requireModelResource('model-catalog.v1.json');
+const ProviderSchema = z.enum([
+    'claude', 'codex', 'copilot', 'cursor', 'factory', 'hermes',
+    'opencode', 'openclaw', 'openhuman', 'warp', 'windsurf',
+]);
+const OutcomeSchema = z.enum([
+    'native', 'compiled', 'inherited', 'global-only', 'informational', 'unsupported',
+]);
+const CapabilityEntrySchema = z.object({
+    agent: OutcomeSchema,
+    skill: OutcomeSchema,
+    globalChild: OutcomeSchema,
+    identifierSyntax: z.string().min(1),
+    effortValues: z.array(z.string().min(1)).optional(),
+    inheritance: z.string().min(1),
+    invalidPinFallback: z.string().min(1),
+    configTarget: z.string().min(1),
+    artifactFormat: z.string().min(1),
+    verification: z.string().min(1),
+    sourceUrl: z.string().url(),
+    verifiedAt: z.string().date(),
+});
+const CapabilityRegistrySchema = z.object({
+    version: z.literal('1.0.0'),
+    verifiedAt: z.string().date(),
+    providers: z.record(ProviderSchema, CapabilityEntrySchema),
+});
+const CatalogModelSchema = z.object({
+    id: z.string().min(1),
+    status: z.enum(['active', 'deprecated', 'unverified']),
+    fallback: z.string().min(1).optional(),
+    observed: z.boolean().optional(),
+});
+const CatalogProviderSchema = z.object({
+    roles: z.object({
+        reasoning: CatalogModelSchema,
+        coding: CatalogModelSchema,
+        efficiency: CatalogModelSchema,
+    }),
+    sourceUrl: z.string().url(),
+    verifiedAt: z.string().date(),
+});
+const CatalogSchema = z.object({
+    version: z.literal('1.0.0'),
+    refreshedAt: z.string().date(),
+    staleAfterDays: z.number().int().positive(),
+    providers: z.record(ProviderSchema, CatalogProviderSchema),
+});
+const PolicySchema = z.object({
+    role: z.enum(['reasoning', 'coding', 'efficiency']),
+    tier: z.enum(['economy', 'standard', 'premium']),
+    effort: z.enum(['minimal', 'low', 'medium', 'high', 'xhigh']).optional(),
+    override: z.string().min(1).optional(),
+}).strict();
+const UserProjectModelConfigSchema = z.object({
+    defaults: z.object({
+        tier: z.enum(['economy', 'standard', 'premium', 'max-quality']).optional(),
+        provider: ProviderSchema.optional(),
+    }).strict().optional(),
+    agentOverrides: z.record(z.string(), z.object({
+        'model-tier': z.enum(['economy', 'standard', 'premium', 'max-quality']).optional(),
+        'model-override': z.string().min(1).optional(),
+        rationale: z.string().min(1).optional(),
+    }).strict()).optional(),
+    customTiers: z.record(z.string(), z.object({
+        description: z.string().min(1),
+        costMultiplier: z.number().nonnegative(),
+        roleMapping: z.object({
+            reasoning: z.enum(['reasoning', 'coding', 'efficiency']),
+            coding: z.enum(['reasoning', 'coding', 'efficiency']),
+            efficiency: z.enum(['reasoning', 'coding', 'efficiency']),
+        }).strict(),
+    }).strict()).optional(),
+    rationale: z.string().optional(),
+}).passthrough();
+let registryCache = null;
+let catalogCache = null;
+export function loadProviderModelCapabilities() {
+    if (!registryCache) {
+        registryCache = CapabilityRegistrySchema.parse(capabilityData);
+        const expected = new Set(ProviderSchema.options);
+        const actual = new Set(Object.keys(registryCache.providers));
+        if (actual.size !== expected.size || [...expected].some(id => !actual.has(id))) {
+            throw new Error('Provider model capability registry must cover all 11 providers');
+        }
+    }
+    return registryCache;
+}
+export function loadProviderModelCatalog() {
+    if (!catalogCache)
+        catalogCache = CatalogSchema.parse(catalogData);
+    return catalogCache;
+}
+export function validateCanonicalModelPolicy(input) {
+    const parsed = PolicySchema.safeParse(input);
+    if (!parsed.success) {
+        return {
+            valid: false,
+            diagnostics: parsed.error.issues.map(issue => ({
+                code: 'MODEL_POLICY_INVALID',
+                severity: 'error',
+                message: `${issue.path.join('.') || 'policy'}: ${issue.message}`,
+            })),
+        };
+    }
+    return { valid: true, policy: parsed.data, diagnostics: [] };
+}
+export function validateUserProjectModelConfig(input) {
+    const parsed = UserProjectModelConfigSchema.safeParse(input);
+    if (parsed.success)
+        return { valid: true, diagnostics: [] };
+    return {
+        valid: false,
+        diagnostics: parsed.error.issues.map(issue => ({
+            code: 'MODEL_POLICY_INVALID',
+            severity: 'error',
+            message: `${issue.path.join('.') || 'config'}: ${issue.message}`,
+        })),
+    };
+}
+function catalogRole(policy) {
+    if (policy.tier === 'economy')
+        return 'efficiency';
+    if (policy.tier === 'premium')
+        return 'reasoning';
+    return policy.role;
+}
+function fieldNames(provider) {
+    switch (provider) {
+        case 'codex': return { model: 'model', effort: 'model_reasoning_effort' };
+        case 'factory': return { model: 'model', effort: 'reasoningEffort' };
+        case 'claude': return { model: 'model', effort: 'effort' };
+        case 'copilot':
+        case 'cursor':
+        case 'opencode': return { model: 'model' };
+        case 'openhuman': return { model: 'model_hint' };
+        case 'openclaw': return { model: 'subagents.model' };
+        default: return {};
+    }
+}
+export function compileModelPolicy(input) {
+    const registry = loadProviderModelCapabilities();
+    const catalog = input.catalog ?? loadProviderModelCatalog();
+    const capability = registry.providers[input.provider];
+    if (!capability)
+        throw new Error(`Unknown provider model capability: ${input.provider}`);
+    const surface = capability[input.artifact];
+    const diagnostics = [];
+    const fields = {};
+    const names = fieldNames(input.provider);
+    const catalogProvider = catalog.providers[input.provider];
+    if (!catalogProvider)
+        throw new Error(`Unknown provider model catalog: ${input.provider}`);
+    const catalogEntry = catalogProvider.roles[catalogRole(input.policy)];
+    const effectiveModel = input.policy.override ?? catalogEntry.id;
+    if (surface === 'unsupported' || surface === 'informational') {
+        diagnostics.push({
+            code: surface === 'unsupported' ? 'MODEL_SURFACE_UNSUPPORTED' : 'MODEL_SURFACE_DEGRADED',
+            severity: surface === 'unsupported' ? 'warning' : 'info',
+            provider: input.provider,
+            message: `${input.provider} cannot enforce ${input.artifact}-scoped model policy (${surface})`,
+        });
+    }
+    else if (surface === 'global-only' || surface === 'inherited') {
+        diagnostics.push({
+            code: 'MODEL_SURFACE_DEGRADED', severity: 'warning', provider: input.provider,
+            message: `${input.provider} compiles ${input.artifact} policy as ${surface}`,
+        });
+    }
+    else if (names.model) {
+        fields[names.model] = effectiveModel;
+    }
+    if (input.policy.effort) {
+        if (names.effort && capability.effortValues?.includes(input.policy.effort)
+            && surface !== 'unsupported' && surface !== 'informational') {
+            fields[names.effort] = input.policy.effort;
+        }
+        else {
+            diagnostics.push({
+                code: 'MODEL_EFFORT_UNSUPPORTED', severity: 'warning', provider: input.provider,
+                message: `${input.provider} does not enforce effort=${input.policy.effort} on ${input.artifact} artifacts`,
+            });
+        }
+    }
+    if (input.policy.override) {
+        diagnostics.push({
+            code: 'MODEL_OVERRIDE_UNVERIFIED', severity: 'warning', provider: input.provider,
+            message: `Exact override ${input.policy.override} requires provider validation`,
+        });
+    }
+    else if (catalogEntry.status === 'deprecated') {
+        diagnostics.push({
+            code: 'MODEL_CATALOG_DEPRECATED', severity: 'error', provider: input.provider,
+            message: `${catalogEntry.id} is deprecated`,
+        });
+    }
+    else if (catalogEntry.status === 'unverified') {
+        diagnostics.push({
+            code: 'MODEL_CATALOG_UNVERIFIED', severity: 'warning', provider: input.provider,
+            message: `${catalogEntry.id} has not been observed on ${input.provider}`,
+        });
+    }
+    const now = input.now ?? new Date();
+    const refreshedAt = new Date(`${catalog.refreshedAt}T00:00:00Z`);
+    const ageDays = Math.floor((now.getTime() - refreshedAt.getTime()) / 86_400_000);
+    if (ageDays > catalog.staleAfterDays) {
+        diagnostics.push({
+            code: 'MODEL_CATALOG_STALE', severity: 'warning', provider: input.provider,
+            message: `Model catalog is ${ageDays} days old (limit ${catalog.staleAfterDays})`,
+        });
+    }
+    return {
+        provider: input.provider,
+        artifact: input.artifact,
+        outcome: surface,
+        effectiveModel: surface === 'unsupported' || surface === 'informational' ? undefined : effectiveModel,
+        effectiveEffort: fields[names.effort ?? ''] ? input.policy.effort : undefined,
+        fields,
+        target: capability.configTarget,
+        source: input.policy.override ? 'override' : (surface === 'inherited' ? 'inheritance' : 'catalog'),
+        diagnostics,
+    };
+}
+function tomlString(value) { return JSON.stringify(value); }
+export function renderCodexAgentToml(definition) {
+    const required = [
+        ['name', definition.name],
+        ['description', definition.description],
+        ['developer_instructions', definition.developerInstructions],
+    ];
+    for (const [field, value] of required) {
+        if (!value.trim())
+            throw new Error(`Codex custom agent requires ${field}`);
+    }
+    const lines = required.map(([field, value]) => `${field} = ${tomlString(value)}`);
+    if (definition.model)
+        lines.push(`model = ${tomlString(definition.model)}`);
+    if (definition.modelReasoningEffort) {
+        lines.push(`model_reasoning_effort = ${tomlString(definition.modelReasoningEffort)}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function resetModelPolicyCachesForTests() {
+    registryCache = null;
+    catalogCache = null;
+}
+//# sourceMappingURL=provider-policy.js.map

package/dist/src/models/resolver.js

@@ -0,0 +1,245 @@
+/**
+ * Model Resolver
+ * Resolves agent names and roles to concrete model identifiers using tier system
+ *
+ * @implements @.aiwg/architecture/ADR-015-enhanced-model-selection.md
+ * @architecture @.aiwg/architecture/enhanced-model-selection-design.md
+ */
+import { ConfigLoader } from './config-loader.js';
+/**
+ * Resolves models for agents using tier system
+ */
+export class ModelResolver {
+    config = null;
+    loader;
+    options;
+    constructor(options = {}, projectPath) {
+        this.options = {
+            respectMinimums: true,
+            ...options,
+        };
+        this.loader = new ConfigLoader(projectPath);
+    }
+    /**
+     * Resolve model for an agent
+     *
+     * @param agentName - Name of the agent
+     * @param agentRole - Role hint from agent frontmatter (legacy 'model' field)
+     * @param agentTier - Tier from agent frontmatter (new 'model-tier' field)
+     * @returns Resolved model information
+     */
+    async resolve(agentName, agentRole, agentTier) {
+        const config = await this.getConfig();
+        // Determine effective tier and role
+        const { tier, role, source } = this.determineEffectiveTierAndRole(agentName, agentRole, agentTier, config);
+        // Check for direct model override (bypasses tier system)
+        const override = config.agentOverrides[agentName];
+        if (override?.['model-override']) {
+            return {
+                modelId: override['model-override'],
+                provider: this.options.provider || config.defaults.provider,
+                tier,
+                role,
+                source: 'agent',
+            };
+        }
+        // Resolve tier + role to concrete model
+        const modelId = this.resolveModelId(tier, role, config);
+        return {
+            modelId,
+            provider: this.options.provider || config.defaults.provider,
+            tier,
+            role,
+            source,
+        };
+    }
+    /**
+     * Determine effective tier and role for an agent
+     */
+    determineEffectiveTierAndRole(agentName, agentRole, agentTier, config) {
+        // 1. CLI tier takes precedence
+        if (this.options.tier) {
+            const role = this.determineRole(agentName, agentRole, config);
+            return {
+                tier: this.applyMinimumTier(agentName, this.options.tier, config),
+                role,
+                source: 'cli',
+            };
+        }
+        // 2. Agent frontmatter tier
+        const agentOverride = config.agentOverrides[agentName];
+        if (agentTier || agentOverride?.['model-tier']) {
+            const tier = agentTier || agentOverride['model-tier'];
+            const role = this.determineRole(agentName, agentRole, config);
+            return {
+                tier: this.applyMinimumTier(agentName, tier, config),
+                role,
+                source: 'agent',
+            };
+        }
+        // 3. Default tier from config
+        const defaultTier = config.defaults.tier;
+        const role = this.determineRole(agentName, agentRole, config);
+        return {
+            tier: this.applyMinimumTier(agentName, defaultTier, config),
+            role,
+            source: 'default',
+        };
+    }
+    /**
+     * Determine role for agent
+     */
+    determineRole(agentName, agentRole, config) {
+        // If explicit role provided, use it
+        if (agentRole) {
+            return agentRole;
+        }
+        // Check agent role assignments
+        if (config?.agentRoleAssignments) {
+            for (const category of Object.values(config.agentRoleAssignments)) {
+                if (category.agents.includes(agentName)) {
+                    return category.defaultRole;
+                }
+            }
+        }
+        // Default to 'coding' as reasonable middle ground
+        return 'coding';
+    }
+    /**
+     * Apply minimum tier constraint if respectMinimums is true
+     */
+    applyMinimumTier(agentName, requestedTier, config) {
+        if (!this.options.respectMinimums) {
+            return requestedTier;
+        }
+        // Find agent's minimum tier
+        for (const category of Object.values(config.agentRoleAssignments || {})) {
+            if (category.agents.includes(agentName)) {
+                const minimumTier = category.minimumTier;
+                return this.maxTier(requestedTier, minimumTier);
+            }
+        }
+        return requestedTier;
+    }
+    /**
+     * Return the higher of two tiers
+     */
+    maxTier(tier1, tier2) {
+        const tierOrder = ['economy', 'standard', 'premium', 'max-quality'];
+        const index1 = tierOrder.indexOf(tier1);
+        const index2 = tierOrder.indexOf(tier2);
+        return tierOrder[Math.max(index1, index2)];
+    }
+    /**
+     * Resolve tier + role to concrete model ID
+     */
+    resolveModelId(tier, role, config) {
+        const provider = this.options.provider || config.defaults.provider;
+        let providerDef = config.providers[provider];
+        if (!providerDef) {
+            throw new Error(`Provider ${provider} not found in configuration`);
+        }
+        // Resolve inheritance
+        providerDef = this.loader.resolveProviderInheritance(providerDef, config.providers);
+        // Check for tier-specific override first
+        if (providerDef.tierOverrides?.[tier]?.[role]) {
+            return providerDef.tierOverrides[tier][role];
+        }
+        // Apply tier's role mapping
+        const tierDef = config.tiers[tier];
+        if (!tierDef) {
+            throw new Error(`Tier ${tier} not found in configuration`);
+        }
+        const mappedRole = tierDef.roleMapping[role];
+        // Get model for mapped role
+        const modelDef = providerDef.models?.[mappedRole];
+        if (!modelDef) {
+            throw new Error(`Model not found for provider ${provider}, role ${mappedRole}`);
+        }
+        return modelDef.default;
+    }
+    /**
+     * Get model info by ID or alias
+     */
+    async getModelInfo(modelIdOrAlias) {
+        const config = await this.getConfig();
+        const provider = this.options.provider || config.defaults.provider;
+        let providerDef = config.providers[provider];
+        if (!providerDef) {
+            return null;
+        }
+        // Resolve inheritance
+        providerDef = this.loader.resolveProviderInheritance(providerDef, config.providers);
+        // Check shorthand aliases
+        const resolvedId = config.shorthand[modelIdOrAlias] || modelIdOrAlias;
+        // Search through all roles
+        for (const [roleName, modelDef] of Object.entries(providerDef.models || {})) {
+            if (modelDef.default === resolvedId || modelDef.aliases?.includes(modelIdOrAlias)) {
+                return {
+                    id: modelDef.default,
+                    provider,
+                    role: roleName,
+                    aliases: modelDef.aliases || [],
+                    capabilities: modelDef.capabilities || [],
+                    contextWindow: modelDef.contextWindow || 0,
+                    costPer1kTokens: modelDef.costPer1kTokens,
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * List all available models for provider
+     */
+    async listModels(provider) {
+        const config = await this.getConfig();
+        const targetProvider = provider || this.options.provider || config.defaults.provider;
+        let providerDef = config.providers[targetProvider];
+        if (!providerDef) {
+            return [];
+        }
+        // Resolve inheritance
+        providerDef = this.loader.resolveProviderInheritance(providerDef, config.providers);
+        const models = [];
+        for (const [roleName, modelDef] of Object.entries(providerDef.models || {})) {
+            models.push({
+                id: modelDef.default,
+                provider: targetProvider,
+                role: roleName,
+                aliases: modelDef.aliases || [],
+                capabilities: modelDef.capabilities || [],
+                contextWindow: modelDef.contextWindow || 0,
+                costPer1kTokens: modelDef.costPer1kTokens,
+            });
+        }
+        return models;
+    }
+    /**
+     * List available tiers
+     */
+    async listTiers() {
+        const config = await this.getConfig();
+        return Object.entries(config.tiers).map(([tierName, tierDef]) => ({
+            tier: tierName,
+            description: tierDef.description,
+            costMultiplier: tierDef.costMultiplier,
+        }));
+    }
+    /**
+     * Get configuration (cached)
+     */
+    async getConfig() {
+        if (!this.config) {
+            this.config = await this.loader.load();
+        }
+        return this.config;
+    }
+    /**
+     * Clear cache (useful for testing)
+     */
+    clearCache() {
+        this.config = null;
+        this.loader.clearCache();
+    }
+}
+//# sourceMappingURL=resolver.js.map

package/dist/src/models/router.js

@@ -0,0 +1,70 @@
+/**
+ * Provider-neutral model-tier routing primitive.
+ *
+ * This is deliberately a policy decision helper, not a provider switcher.
+ * Callers use it to decide whether a task stays on the current/default
+ * model, escalates to a capable work tier, or requires explicit premium
+ * confirmation before routing.
+ *
+ * @implements #1185
+ */
+const RUNTIME_TO_MODEL_TIER = {
+    0: null,
+    1: 'economy',
+    2: 'standard',
+    3: 'premium',
+};
+function clampRuntimeTier(tier, fallback) {
+    return tier === 0 || tier === 1 || tier === 2 || tier === 3 ? tier : fallback;
+}
+export function routeModelTier(request = {}) {
+    const defaultTier = clampRuntimeTier(request.defaultTier, 1);
+    const maxAutoTier = clampRuntimeTier(request.maxAutoTier, request.unattended ? 1 : 2);
+    let tier = defaultTier;
+    let source = 'default';
+    const rationale = [];
+    if (request.deterministic) {
+        tier = 0;
+        source = 'deterministic';
+        rationale.push('deterministic tool/cache/existing answer is sufficient');
+    }
+    else if (request.requestedPremium) {
+        tier = 3;
+        source = 'request';
+        rationale.push('premium tier was explicitly requested');
+    }
+    else if (request.highImpact) {
+        tier = 3;
+        source = 'impact';
+        rationale.push('high-impact domain requires supervised premium routing');
+    }
+    else if (request.complex) {
+        tier = Math.max(defaultTier, 2);
+        source = 'complexity';
+        rationale.push('complex or multi-step work needs a capable work tier');
+    }
+    else if (request.routine) {
+        tier = Math.min(defaultTier, 1);
+        source = 'default';
+        rationale.push('routine work stays at the default/cheap tier');
+    }
+    else {
+        rationale.push('no escalation signal present');
+    }
+    const requiresConfirmation = (tier === 3 && !request.premiumAuthorized) || tier > maxAutoTier;
+    if (requiresConfirmation) {
+        rationale.push(tier === 3
+            ? 'Tier 3 requires explicit human confirmation'
+            : `policy permits auto-routing only through Tier ${maxAutoTier}`);
+    }
+    const summaryRequired = tier > defaultTier;
+    return {
+        tier,
+        modelTier: RUNTIME_TO_MODEL_TIER[tier],
+        requiresConfirmation,
+        summaryRequired,
+        source: requiresConfirmation && tier > maxAutoTier ? 'policy' : source,
+        rationale,
+    };
+}
+//# sourceMappingURL=router.js.map

package/dist/src/models/types.js

@@ -0,0 +1,8 @@
+/**
+ * TypeScript types for Enhanced Model Selection System (Phase 1)
+ *
+ * @implements @.aiwg/architecture/ADR-015-enhanced-model-selection.md
+ * @architecture @.aiwg/architecture/enhanced-model-selection-design.md
+ */
+export {};
+//# sourceMappingURL=types.js.map