@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/metrics/context-budget.js

@@ -0,0 +1,174 @@
+/**
+ * Context Budget — configurable context/generation token split
+ *
+ * Manages token budgets for context windows with a default 70/30 split
+ * (70% context, 30% generation). Supports priority scoring based on
+ * recency, similarity, and @-mention presence.
+ *
+ * @module metrics/context-budget
+ * @issue #144
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+import { estimateTokens } from './token-counter.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_CONFIG = {
+    totalTokens: 200000,
+    contextFraction: 0.70,
+    generationFraction: 0.30,
+    warningThreshold: 0.85,
+    hardLimitThreshold: 0.95,
+};
+const CONFIG_PATH = '.aiwg/config/context-budget.json';
+// ============================================================================
+// ContextBudgetManager
+// ============================================================================
+export class ContextBudgetManager {
+    config;
+    items;
+    projectPath;
+    constructor(projectPath, config) {
+        this.projectPath = projectPath;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.items = [];
+        // Validate fractions sum to 1
+        const total = this.config.contextFraction + this.config.generationFraction;
+        if (Math.abs(total - 1.0) > 0.001) {
+            throw new Error(`Context and generation fractions must sum to 1.0, got ${total}`);
+        }
+    }
+    get contextBudget() {
+        return Math.floor(this.config.totalTokens * this.config.contextFraction);
+    }
+    get generationBudget() {
+        return Math.floor(this.config.totalTokens * this.config.generationFraction);
+    }
+    addItem(id, content, sourceType, similarity) {
+        const tokens = estimateTokens(content);
+        const priority = calculatePriority(sourceType, similarity);
+        const item = {
+            id,
+            content,
+            tokens,
+            priority,
+            source: {
+                type: sourceType,
+                addedAt: new Date().toISOString(),
+                similarity,
+            },
+        };
+        this.items.push(item);
+        return item;
+    }
+    removeItem(id) {
+        const index = this.items.findIndex((item) => item.id === id);
+        if (index === -1)
+            return false;
+        this.items.splice(index, 1);
+        return true;
+    }
+    getStatus() {
+        const contextUsed = this.items.reduce((sum, item) => sum + item.tokens, 0);
+        const contextBudget = this.contextBudget;
+        const usageFraction = contextBudget > 0 ? contextUsed / contextBudget : 0;
+        let level;
+        if (usageFraction > 1.0) {
+            level = 'exceeded';
+        }
+        else if (usageFraction >= this.config.hardLimitThreshold) {
+            level = 'critical';
+        }
+        else if (usageFraction >= this.config.warningThreshold) {
+            level = 'warning';
+        }
+        else {
+            level = 'ok';
+        }
+        return {
+            contextBudget,
+            generationBudget: this.generationBudget,
+            contextUsed,
+            contextRemaining: Math.max(0, contextBudget - contextUsed),
+            usageFraction: Math.round(usageFraction * 10000) / 10000,
+            level,
+            itemCount: this.items.length,
+        };
+    }
+    wouldExceed(content) {
+        const tokens = estimateTokens(content);
+        const status = this.getStatus();
+        return (status.contextUsed + tokens) > this.contextBudget;
+    }
+    degrade() {
+        const targetTokens = Math.floor(this.contextBudget * this.config.warningThreshold);
+        const sorted = [...this.items].sort((a, b) => a.priority - b.priority);
+        let currentTokens = this.items.reduce((sum, item) => sum + item.tokens, 0);
+        const dropped = [];
+        const droppedIds = new Set();
+        for (const item of sorted) {
+            if (currentTokens <= targetTokens)
+                break;
+            if (item.source.type === 'system')
+                continue;
+            dropped.push(item);
+            droppedIds.add(item.id);
+            currentTokens -= item.tokens;
+        }
+        this.items = this.items.filter((item) => !droppedIds.has(item.id));
+        const tokensFreed = dropped.reduce((sum, item) => sum + item.tokens, 0);
+        return {
+            kept: [...this.items],
+            dropped,
+            tokensFreed,
+        };
+    }
+    getItems() {
+        return [...this.items].sort((a, b) => b.priority - a.priority);
+    }
+    async loadConfig() {
+        try {
+            const configPath = path.join(this.projectPath, CONFIG_PATH);
+            const content = await fs.readFile(configPath, 'utf-8');
+            const loaded = JSON.parse(content);
+            this.config = { ...DEFAULT_CONFIG, ...loaded };
+        }
+        catch {
+            // Use defaults
+        }
+    }
+    async saveConfig() {
+        const configPath = path.join(this.projectPath, CONFIG_PATH);
+        await fs.mkdir(path.dirname(configPath), { recursive: true });
+        await fs.writeFile(configPath, JSON.stringify(this.config, null, 2), 'utf-8');
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+}
+// ============================================================================
+// Priority Scoring
+// ============================================================================
+export function calculatePriority(sourceType, similarity) {
+    let base;
+    switch (sourceType) {
+        case 'system':
+            base = 1.0;
+            break;
+        case 'at-mention':
+            base = 0.9;
+            break;
+        case 'user':
+            base = 0.7;
+            break;
+        case 'auto':
+            base = 0.5;
+            break;
+        default:
+            base = 0.3;
+    }
+    const similarityBonus = similarity ? similarity * 0.1 : 0;
+    return Math.min(1.0, base + similarityBonus);
+}
+//# sourceMappingURL=context-budget.js.map

package/dist/src/metrics/token-counter.js

@@ -0,0 +1,133 @@
+/**
+ * Token Counter — character-based token estimation
+ *
+ * Provides lightweight token estimation using the 4 chars per token
+ * heuristic, non-blank line counting, and tokens/line ratio calculation.
+ * Benchmark target: 124 tokens/line (MetaGPT, REF-013).
+ *
+ * @module metrics/token-counter
+ * @issue #173
+ * @schema @agentic/code/frameworks/sdlc-complete/schemas/flows/token-efficiency.yaml
+ */
+// ============================================================================
+// Constants
+// ============================================================================
+/** Average characters per token (GPT/Claude heuristic) */
+export const CHARS_PER_TOKEN = 4;
+/** MetaGPT benchmark: 124 tokens per line (REF-013) */
+export const BENCHMARK_TOKENS_PER_LINE = 124;
+/** Typical LLM baseline: ~200 tokens per line */
+export const BASELINE_TOKENS_PER_LINE = 200;
+/** Green threshold: at or below benchmark */
+export const GREEN_MAX_TOKENS_PER_LINE = 124;
+/** Yellow threshold: between benchmark and 150 */
+export const YELLOW_MAX_TOKENS_PER_LINE = 150;
+// ============================================================================
+// Core Functions
+// ============================================================================
+/**
+ * Estimate token count from text content using character-based heuristic.
+ *
+ * @param content - Text content to estimate tokens for
+ * @returns Estimated token count
+ */
+export function estimateTokens(content) {
+    if (!content)
+        return 0;
+    return Math.ceil(content.length / CHARS_PER_TOKEN);
+}
+/**
+ * Count non-blank lines in content.
+ *
+ * @param content - Text content
+ * @returns Number of non-blank lines
+ */
+export function countNonBlankLines(content) {
+    if (!content)
+        return 0;
+    const lines = content.split('\n');
+    return lines.filter((line) => line.trim().length > 0).length;
+}
+/**
+ * Count total lines in content.
+ *
+ * @param content - Text content
+ * @returns Total line count
+ */
+export function countTotalLines(content) {
+    if (!content)
+        return 0;
+    return content.split('\n').length;
+}
+/**
+ * Perform full token count analysis on content.
+ *
+ * @param content - Text content to analyze
+ * @returns Token count with line metrics
+ */
+export function countTokens(content) {
+    const tokens = estimateTokens(content);
+    const nonBlankLines = countNonBlankLines(content);
+    const totalLines = countTotalLines(content);
+    const tokensPerLine = nonBlankLines > 0 ? tokens / nonBlankLines : 0;
+    return {
+        tokens,
+        characters: content ? content.length : 0,
+        nonBlankLines,
+        totalLines,
+        tokensPerLine: Math.round(tokensPerLine * 100) / 100,
+    };
+}
+// ============================================================================
+// Threshold Evaluation
+// ============================================================================
+/**
+ * Determine threshold status for a tokens/line ratio.
+ *
+ * @param tokensPerLine - Tokens per non-blank line ratio
+ * @returns Threshold status with level, message, and action
+ */
+export function evaluateThreshold(tokensPerLine) {
+    if (tokensPerLine <= GREEN_MAX_TOKENS_PER_LINE) {
+        return {
+            level: 'green',
+            message: 'Meeting benchmark',
+            action: 'none',
+        };
+    }
+    if (tokensPerLine <= YELLOW_MAX_TOKENS_PER_LINE) {
+        return {
+            level: 'yellow',
+            message: 'Review for optimization',
+            action: 'flag_for_review',
+        };
+    }
+    return {
+        level: 'red',
+        message: 'Requires optimization',
+        action: 'generate_recommendations',
+    };
+}
+/**
+ * Analyze token efficiency with full benchmark comparison.
+ *
+ * @param content - Text content to analyze
+ * @returns Full efficiency result with threshold and benchmark comparison
+ */
+export function analyzeTokenEfficiency(content) {
+    const count = countTokens(content);
+    const threshold = evaluateThreshold(count.tokensPerLine);
+    const vsBenchmark = count.tokensPerLine > 0
+        ? Math.round(((count.tokensPerLine - BENCHMARK_TOKENS_PER_LINE) / BENCHMARK_TOKENS_PER_LINE) * 10000) / 100
+        : 0;
+    const vsBaseline = count.tokensPerLine > 0
+        ? Math.round(((count.tokensPerLine - BASELINE_TOKENS_PER_LINE) / BASELINE_TOKENS_PER_LINE) * 10000) / 100
+        : 0;
+    return {
+        ...count,
+        threshold,
+        vsBenchmark,
+        vsBaseline,
+    };
+}
+//# sourceMappingURL=token-counter.js.map

package/dist/src/models/config-loader.js

@@ -0,0 +1,228 @@
+/**
+ * Model Configuration Loader
+ * Loads and merges model configurations from multiple sources with proper precedence
+ *
+ * @implements @.aiwg/architecture/ADR-015-enhanced-model-selection.md
+ * @architecture @.aiwg/architecture/enhanced-model-selection-design.md
+ */
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { homedir } from 'os';
+import { existsSync } from 'fs';
+import { validateUserProjectModelConfig } from './provider-policy.js';
+/**
+ * Loads and merges model configurations
+ */
+export class ConfigLoader {
+    cache = null;
+    locations;
+    constructor(projectPath) {
+        const aiwgHome = process.env.AIWG_HOME || resolve(homedir(), '.local/share/ai-writing-guide');
+        const userConfigDir = process.env.AIWG_CONFIG || resolve(homedir(), '.config/aiwg');
+        this.locations = {
+            aiwgDefault: resolve(aiwgHome, 'agentic/code/frameworks/sdlc-complete/config/models-v2.json'),
+            userConfig: resolve(userConfigDir, 'models.json'),
+            projectConfig: resolve(projectPath || process.cwd(), 'models.json'),
+        };
+    }
+    /**
+     * Load and merge all configurations
+     * Precedence: project > user > AIWG default
+     */
+    async load() {
+        if (this.cache) {
+            return this.cache;
+        }
+        // Load all configs
+        const aiwgDefault = await this.loadAiwgDefault();
+        const userConfig = await this.loadUserConfig();
+        const projectConfig = await this.loadProjectConfig();
+        // Merge with precedence
+        const merged = this.merge(aiwgDefault, userConfig, projectConfig);
+        this.cache = merged;
+        return merged;
+    }
+    /**
+     * Load AIWG default configuration
+     */
+    async loadAiwgDefault() {
+        try {
+            const content = await readFile(this.locations.aiwgDefault, 'utf-8');
+            const config = JSON.parse(content);
+            // Validate it's v2 schema
+            if (!config.version || !config.tiers || !config.providers) {
+                throw new Error('Invalid AIWG default config: missing required v2 fields');
+            }
+            return config;
+        }
+        catch (error) {
+            throw new Error(`Failed to load AIWG default config: ${error}`);
+        }
+    }
+    /**
+     * Load user configuration (optional)
+     */
+    async loadUserConfig() {
+        if (!existsSync(this.locations.userConfig)) {
+            return null;
+        }
+        try {
+            const content = await readFile(this.locations.userConfig, 'utf-8');
+            const parsed = JSON.parse(content);
+            const validation = validateUserProjectModelConfig(parsed);
+            if (!validation.valid) {
+                throw new Error(validation.diagnostics.map(item => `${item.code}: ${item.message}`).join('; '));
+            }
+            return parsed;
+        }
+        catch (error) {
+            throw new Error(`Invalid user model config ${this.locations.userConfig}: ${error}`);
+        }
+    }
+    /**
+     * Load project configuration (optional)
+     */
+    async loadProjectConfig() {
+        if (!existsSync(this.locations.projectConfig)) {
+            return null;
+        }
+        try {
+            const content = await readFile(this.locations.projectConfig, 'utf-8');
+            const parsed = JSON.parse(content);
+            const validation = validateUserProjectModelConfig(parsed);
+            if (!validation.valid) {
+                throw new Error(validation.diagnostics.map(item => `${item.code}: ${item.message}`).join('; '));
+            }
+            return parsed;
+        }
+        catch (error) {
+            throw new Error(`Invalid project model config ${this.locations.projectConfig}: ${error}`);
+        }
+    }
+    /**
+     * Merge configurations with proper precedence
+     */
+    merge(aiwgDefault, userConfig, projectConfig) {
+        // Start with AIWG defaults
+        const merged = {
+            defaults: { ...aiwgDefault.defaults },
+            tiers: { ...aiwgDefault.tiers },
+            providers: this.deepCloneProviders(aiwgDefault.providers),
+            agentRoleAssignments: { ...(aiwgDefault.agentRoleAssignments || {}) },
+            shorthand: { ...(aiwgDefault.shorthand || {}) },
+            agentOverrides: {},
+        };
+        // Apply user config
+        if (userConfig) {
+            if (userConfig.defaults) {
+                merged.defaults = { ...merged.defaults, ...userConfig.defaults };
+            }
+            if (userConfig.customTiers) {
+                merged.tiers = { ...merged.tiers, ...userConfig.customTiers };
+            }
+            if (userConfig.agentOverrides) {
+                merged.agentOverrides = { ...userConfig.agentOverrides };
+            }
+        }
+        // Apply project config (highest precedence)
+        if (projectConfig) {
+            if (projectConfig.defaults) {
+                merged.defaults = { ...merged.defaults, ...projectConfig.defaults };
+            }
+            if (projectConfig.customTiers) {
+                merged.tiers = { ...merged.tiers, ...projectConfig.customTiers };
+            }
+            if (projectConfig.agentOverrides) {
+                merged.agentOverrides = { ...merged.agentOverrides, ...projectConfig.agentOverrides };
+            }
+        }
+        return merged;
+    }
+    /**
+     * Deep clone providers to avoid mutation
+     */
+    deepCloneProviders(providers) {
+        const cloned = {};
+        for (const [name, provider] of Object.entries(providers)) {
+            cloned[name] = {
+                ...provider,
+                models: provider.models
+                    ? {
+                        reasoning: provider.models.reasoning ? { ...provider.models.reasoning } : undefined,
+                        coding: provider.models.coding ? { ...provider.models.coding } : undefined,
+                        efficiency: provider.models.efficiency ? { ...provider.models.efficiency } : undefined,
+                    }
+                    : undefined,
+                tierOverrides: provider.tierOverrides ? { ...provider.tierOverrides } : undefined,
+            };
+        }
+        return cloned;
+    }
+    /**
+     * Load v1 config for backwards compatibility
+     */
+    async loadV1Config(path) {
+        if (!existsSync(path)) {
+            return null;
+        }
+        try {
+            const content = await readFile(path, 'utf-8');
+            const config = JSON.parse(content);
+            // Simple heuristic: v1 has provider keys with role objects
+            // v2 has version, tiers, providers structure
+            if ('version' in config && 'tiers' in config) {
+                return null; // This is v2
+            }
+            return config;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Convert v1 config to v2 compatible structure
+     */
+    convertV1ToV2(_v1Config) {
+        const agentOverrides = {};
+        // V1 doesn't have agent overrides, so we just create empty structure
+        // The actual v1 role mappings will be used as defaults in the resolver
+        // _v1Config preserved for future v1 field migration
+        return {
+            agentOverrides,
+        };
+    }
+    /**
+     * Resolve provider inheritance
+     */
+    resolveProviderInheritance(provider, providers) {
+        if (!provider.inherits) {
+            return provider;
+        }
+        const parent = providers[provider.inherits];
+        if (!parent) {
+            throw new Error(`Provider ${provider.inherits} not found for inheritance`);
+        }
+        // Recursively resolve parent
+        const resolvedParent = this.resolveProviderInheritance(parent, providers);
+        // Merge parent into child (child overrides parent)
+        return {
+            ...resolvedParent,
+            ...provider,
+            models: provider.models || resolvedParent.models,
+            tierOverrides: provider.tierOverrides || resolvedParent.tierOverrides,
+        };
+    }
+    /**
+     * Clear cache (useful for testing)
+     */
+    clearCache() {
+        this.cache = null;
+    }
+    /**
+     * Get configuration file locations
+     */
+    getLocations() {
+        return { ...this.locations };
+    }
+}
+//# sourceMappingURL=config-loader.js.map

package/dist/src/models/index.js

@@ -0,0 +1,22 @@
+/**
+ * Enhanced Model Selection System - Public API
+ *
+ * Provides tier-based model selection with:
+ * - Quality tiers (economy, standard, premium, max-quality)
+ * - Provider abstraction (claude, openai, factory, etc.)
+ * - Hierarchical configuration (default < user < project < agent)
+ * - Backwards compatibility with v1 configs
+ *
+ * @implements @.aiwg/architecture/ADR-015-enhanced-model-selection.md
+ * @architecture @.aiwg/architecture/enhanced-model-selection-design.md
+ *
+ * @module models
+ */
+// Export ConfigLoader
+export { ConfigLoader } from './config-loader.js';
+// Export ModelResolver
+export { ModelResolver } from './resolver.js';
+// Export provider-neutral runtime tier routing primitive
+export { routeModelTier } from './router.js';
+export { compileModelPolicy, loadProviderModelCapabilities, loadProviderModelCatalog, renderCodexAgentToml, resetModelPolicyCachesForTests, validateCanonicalModelPolicy, validateUserProjectModelConfig, } from './provider-policy.js';
+//# sourceMappingURL=index.js.map

package/dist/src/models/model-capabilities.v1.json

@@ -0,0 +1,120 @@
+{
+  "$schema": "../../../schemas/models/provider-model-capabilities.v1.schema.json",
+  "version": "1.0.0",
+  "verifiedAt": "2026-07-20",
+  "providers": {
+    "claude": {
+      "agent": "native", "skill": "native", "globalChild": "inherited",
+      "identifierSyntax": "Claude alias or accepted Anthropic model ID",
+      "effortValues": ["low", "medium", "high"],
+      "inheritance": "Omitted agent or skill fields inherit the invoking session",
+      "invalidPinFallback": "Provider validation/error; never assume fallback",
+      "configTarget": ".claude/agents/*.md and skill SKILL.md frontmatter",
+      "artifactFormat": "YAML frontmatter plus Markdown",
+      "verification": "Inspect deployed frontmatter and bounded invocation metadata",
+      "sourceUrl": "https://code.claude.com/docs/en/sub-agents", "verifiedAt": "2026-07-20"
+    },
+    "codex": {
+      "agent": "native", "skill": "unsupported", "globalChild": "inherited",
+      "identifierSyntax": "Codex model slug accepted by config.toml",
+      "effortValues": ["minimal", "low", "medium", "high", "xhigh"],
+      "inheritance": "Omitted model and model_reasoning_effort inherit the parent session",
+      "invalidPinFallback": "Strict config or runtime validation; never assume fallback",
+      "configTarget": ".codex/agents/*.toml",
+      "artifactFormat": "Standalone TOML custom-agent configuration",
+      "verification": "Parse TOML and load in Codex custom-agent registry",
+      "sourceUrl": "https://learn.chatgpt.com/docs/agent-configuration/subagents", "verifiedAt": "2026-07-20"
+    },
+    "copilot": {
+      "agent": "native", "skill": "unsupported", "globalChild": "inherited",
+      "identifierSyntax": "Current Copilot custom-agent model identifier",
+      "inheritance": "Omitted model uses session or Auto selection",
+      "invalidPinFallback": "Plan/admin/catalog dependent; report unresolved",
+      "configTarget": ".github/agents/*.agent.md",
+      "artifactFormat": "YAML frontmatter plus Markdown",
+      "verification": "Schema fixture and entitled Copilot invocation",
+      "sourceUrl": "https://docs.github.com/en/copilot/reference/custom-agents-configuration", "verifiedAt": "2026-07-20"
+    },
+    "cursor": {
+      "agent": "native", "skill": "unsupported", "globalChild": "inherited",
+      "identifierSyntax": "Cursor-supported exact model ID",
+      "inheritance": "Omitted model inherits parent selection",
+      "invalidPinFallback": "Plan/admin fallback may apply; record observed result",
+      "configTarget": ".cursor/agents/*.md",
+      "artifactFormat": "YAML frontmatter plus Markdown",
+      "verification": "Schema fixture and entitled Cursor invocation",
+      "sourceUrl": "https://cursor.com/docs/subagents", "verifiedAt": "2026-07-20"
+    },
+    "factory": {
+      "agent": "native", "skill": "informational", "globalChild": "native",
+      "identifierSyntax": "Factory model ID or Light/Medium/Heavy complexity",
+      "effortValues": ["low", "medium", "high"],
+      "inheritance": "Droid may inherit org/session model policy",
+      "invalidPinFallback": "Organization policy may substitute; record observed result",
+      "configTarget": ".factory/droids/*.md and Factory settings",
+      "artifactFormat": "YAML frontmatter plus Markdown",
+      "verification": "Fixture validation and Factory CLI model report",
+      "sourceUrl": "https://docs.factory.ai/cli/configuration/custom-droids", "verifiedAt": "2026-07-20"
+    },
+    "opencode": {
+      "agent": "native", "skill": "unsupported", "globalChild": "inherited",
+      "identifierSyntax": "provider/model-id",
+      "inheritance": "Omitted agent model inherits global primary model",
+      "invalidPinFallback": "Installed provider catalog determines error/fallback",
+      "configTarget": ".opencode/agent/*.md",
+      "artifactFormat": "YAML frontmatter plus Markdown",
+      "verification": "Inspect artifact and OpenCode model registry",
+      "sourceUrl": "https://opencode.ai/docs/agents", "verifiedAt": "2026-07-20"
+    },
+    "warp": {
+      "agent": "global-only", "skill": "unsupported", "globalChild": "native",
+      "identifierSyntax": "Warp saved-profile or run model identifier",
+      "inheritance": "All delegated work uses run/profile selection",
+      "invalidPinFallback": "Profile availability dependent",
+      "configTarget": "Warp agent profile or run configuration",
+      "artifactFormat": "Saved profile / run control plane",
+      "verification": "Inspect active profile and run metadata",
+      "sourceUrl": "https://docs.warp.dev/agent-platform/capabilities/agent-profiles-permissions", "verifiedAt": "2026-07-20"
+    },
+    "windsurf": {
+      "agent": "unsupported", "skill": "unsupported", "globalChild": "inherited",
+      "identifierSyntax": "UI-selected provider model",
+      "inheritance": "Child behavior follows the main UI session",
+      "invalidPinFallback": "No portable custom-child selector",
+      "configTarget": "No supported portable artifact field",
+      "artifactFormat": "Informational policy only",
+      "verification": "Assert unsupported fields are omitted",
+      "sourceUrl": "https://docs.devin.ai/desktop/cascade/skills", "verifiedAt": "2026-07-20"
+    },
+    "openclaw": {
+      "agent": "native", "skill": "unsupported", "globalChild": "native",
+      "identifierSyntax": "Configured provider/model identifier",
+      "inheritance": "Per-agent or per-spawn override falls back to global subagent model",
+      "invalidPinFallback": "Provider/account fallback must be observed",
+      "configTarget": "OpenClaw subagent configuration",
+      "artifactFormat": "JSON/JSONC runtime configuration",
+      "verification": "Inspect resolved subagent metadata",
+      "sourceUrl": "https://docs.openclaw.ai/tools/subagents", "verifiedAt": "2026-07-20"
+    },
+    "hermes": {
+      "agent": "global-only", "skill": "unsupported", "globalChild": "native",
+      "identifierSyntax": "Hermes delegation provider and model",
+      "inheritance": "All delegated workers share one configured model",
+      "invalidPinFallback": "Provider resolution is global; report actual model",
+      "configTarget": "Hermes delegation configuration",
+      "artifactFormat": "Global CLI/config setting",
+      "verification": "Inspect Hermes delegation configuration",
+      "sourceUrl": "https://hermes-agent.nousresearch.com/docs/user-guide/features/delegation", "verifiedAt": "2026-07-20"
+    },
+    "openhuman": {
+      "agent": "compiled", "skill": "unsupported", "globalChild": "inherited",
+      "identifierSyntax": "Inherit, Exact(model), or semantic Hint",
+      "inheritance": "Inherit delegates selection to router/provider defaults",
+      "invalidPinFallback": "Exact pins validate; semantic hints route dynamically",
+      "configTarget": "OpenHuman agent TOML",
+      "artifactFormat": "Standalone TOML agent definition",
+      "verification": "Parse against OpenHuman definition schema",
+      "sourceUrl": "https://github.com/tinyhumansai/openhuman/blob/main/src/openhuman/agent/harness/definition.rs", "verifiedAt": "2026-07-20"
+    }
+  }
+}