@liangjie559567/ultrapower 5.0.4

package/dist/features/delegation-enforcer.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Delegation Enforcer
+ *
+ * Middleware that ensures model parameter is always present in Task/Agent calls.
+ * Automatically injects the default model from agent definitions when not specified.
+ *
+ * This solves the problem where Claude Code doesn't automatically apply models
+ * from agent definitions - every Task call must explicitly pass the model parameter.
+ */
+import type { ModelType } from '../shared/types.js';
+/**
+ * Agent input structure from Claude Agent SDK
+ */
+export interface AgentInput {
+    description: string;
+    prompt: string;
+    subagent_type: string;
+    model?: 'sonnet' | 'opus' | 'haiku';
+    resume?: string;
+    run_in_background?: boolean;
+}
+/**
+ * Result of model enforcement
+ */
+export interface EnforcementResult {
+    /** Original input */
+    originalInput: AgentInput;
+    /** Modified input with model enforced */
+    modifiedInput: AgentInput;
+    /** Whether model was auto-injected */
+    injected: boolean;
+    /** The model that was used */
+    model: ModelType;
+    /** Warning message (only if OMC_DEBUG=true) */
+    warning?: string;
+}
+/**
+ * Enforce model parameter for an agent delegation call
+ *
+ * If model is explicitly specified, it's preserved.
+ * If not, the default model from agent definition is injected.
+ *
+ * @param agentInput - The agent/task input parameters
+ * @returns Enforcement result with modified input
+ * @throws Error if agent type has no default model
+ */
+export declare function enforceModel(agentInput: AgentInput): EnforcementResult;
+/**
+ * Check if tool input is an agent delegation call
+ */
+export declare function isAgentCall(toolName: string, toolInput: unknown): toolInput is AgentInput;
+/**
+ * Process a pre-tool-use hook for model enforcement
+ *
+ * @param toolName - The tool being invoked
+ * @param toolInput - The tool input parameters
+ * @returns Modified tool input with model enforced, or original if not an agent call
+ */
+export declare function processPreToolUse(toolName: string, toolInput: unknown): {
+    modifiedInput: unknown;
+    warning?: string;
+};
+/**
+ * Get model for an agent type (for testing/debugging)
+ *
+ * @param agentType - The agent type (with or without ultrapower: prefix)
+ * @returns The default model for the agent
+ * @throws Error if agent type not found or has no model
+ */
+export declare function getModelForAgent(agentType: string): ModelType;
+//# sourceMappingURL=delegation-enforcer.d.ts.map

package/dist/features/delegation-enforcer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation-enforcer.d.ts","sourceRoot":"","sources":["../../src/features/delegation-enforcer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,qBAAqB;IACrB,aAAa,EAAE,UAAU,CAAC;IAC1B,yCAAyC;IACzC,aAAa,EAAE,UAAU,CAAC;IAC1B,sCAAsC;IACtC,QAAQ,EAAE,OAAO,CAAC;IAClB,8BAA8B;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,UAAU,GAAG,iBAAiB,CAgDtE;AAYD;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,SAAS,IAAI,UAAU,CAezF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,OAAO,GACjB;IAAE,aAAa,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAkB9C;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAc7D"}

package/dist/features/delegation-enforcer.js

@@ -0,0 +1,128 @@
+/**
+ * Delegation Enforcer
+ *
+ * Middleware that ensures model parameter is always present in Task/Agent calls.
+ * Automatically injects the default model from agent definitions when not specified.
+ *
+ * This solves the problem where Claude Code doesn't automatically apply models
+ * from agent definitions - every Task call must explicitly pass the model parameter.
+ */
+import { getAgentDefinitions } from '../agents/definitions.js';
+/**
+ * Enforce model parameter for an agent delegation call
+ *
+ * If model is explicitly specified, it's preserved.
+ * If not, the default model from agent definition is injected.
+ *
+ * @param agentInput - The agent/task input parameters
+ * @returns Enforcement result with modified input
+ * @throws Error if agent type has no default model
+ */
+export function enforceModel(agentInput) {
+    // If model is already specified, return as-is
+    if (agentInput.model) {
+        return {
+            originalInput: agentInput,
+            modifiedInput: agentInput,
+            injected: false,
+            model: agentInput.model,
+        };
+    }
+    // Extract agent type (strip ultrapower: prefix if present)
+    const agentType = agentInput.subagent_type.replace(/^ultrapower:/, '');
+    // Get agent definition
+    const agentDefs = getAgentDefinitions();
+    const agentDef = agentDefs[agentType];
+    if (!agentDef) {
+        throw new Error(`Unknown agent type: ${agentType} (from ${agentInput.subagent_type})`);
+    }
+    if (!agentDef.model) {
+        throw new Error(`No default model defined for agent: ${agentType}`);
+    }
+    // Convert ModelType to SDK model type
+    const sdkModel = convertToSdkModel(agentDef.model);
+    // Create modified input with model injected
+    const modifiedInput = {
+        ...agentInput,
+        model: sdkModel,
+    };
+    // Create warning message (only shown if OMC_DEBUG=true)
+    let warning;
+    if (process.env.OMC_DEBUG === 'true') {
+        warning = `[OMC] Auto-injecting model: ${sdkModel} for ${agentType}`;
+    }
+    return {
+        originalInput: agentInput,
+        modifiedInput,
+        injected: true,
+        model: agentDef.model,
+        warning,
+    };
+}
+/**
+ * Convert ModelType to SDK model format
+ */
+function convertToSdkModel(model) {
+    if (model === 'inherit') {
+        return 'sonnet'; // Default fallback
+    }
+    return model;
+}
+/**
+ * Check if tool input is an agent delegation call
+ */
+export function isAgentCall(toolName, toolInput) {
+    if (toolName !== 'Agent' && toolName !== 'Task') {
+        return false;
+    }
+    if (!toolInput || typeof toolInput !== 'object') {
+        return false;
+    }
+    const input = toolInput;
+    return (typeof input.subagent_type === 'string' &&
+        typeof input.prompt === 'string' &&
+        typeof input.description === 'string');
+}
+/**
+ * Process a pre-tool-use hook for model enforcement
+ *
+ * @param toolName - The tool being invoked
+ * @param toolInput - The tool input parameters
+ * @returns Modified tool input with model enforced, or original if not an agent call
+ */
+export function processPreToolUse(toolName, toolInput) {
+    // Check if this is an agent delegation call
+    if (!isAgentCall(toolName, toolInput)) {
+        return { modifiedInput: toolInput };
+    }
+    // Enforce model parameter
+    const result = enforceModel(toolInput);
+    // Log warning if debug mode is enabled and model was injected
+    if (result.warning) {
+        console.warn(result.warning);
+    }
+    return {
+        modifiedInput: result.modifiedInput,
+        warning: result.warning,
+    };
+}
+/**
+ * Get model for an agent type (for testing/debugging)
+ *
+ * @param agentType - The agent type (with or without ultrapower: prefix)
+ * @returns The default model for the agent
+ * @throws Error if agent type not found or has no model
+ */
+export function getModelForAgent(agentType) {
+    const normalizedType = agentType.replace(/^ultrapower:/, '');
+    const agentDefs = getAgentDefinitions();
+    const agentDef = agentDefs[normalizedType];
+    if (!agentDef) {
+        throw new Error(`Unknown agent type: ${normalizedType}`);
+    }
+    if (!agentDef.model) {
+        throw new Error(`No default model defined for agent: ${normalizedType}`);
+    }
+    return agentDef.model;
+}
+//# sourceMappingURL=delegation-enforcer.js.map

package/dist/features/delegation-enforcer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation-enforcer.js","sourceRoot":"","sources":["../../src/features/delegation-enforcer.ts"],"names":[],"mappings":"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"}

package/dist/features/delegation-routing/__tests__/resolver.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resolver.test.d.ts.map

package/dist/features/delegation-routing/__tests__/resolver.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.test.d.ts","sourceRoot":"","sources":["../../../../src/features/delegation-routing/__tests__/resolver.test.ts"],"names":[],"mappings":""}

package/dist/features/delegation-routing/__tests__/resolver.test.js

@@ -0,0 +1,419 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { resolveDelegation, parseFallbackChain } from '../resolver.js';
+describe('resolveDelegation', () => {
+    let consoleWarnSpy;
+    beforeEach(() => {
+        consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleWarnSpy.mockRestore();
+    });
+    // Test 1: Explicit tool takes highest precedence
+    it('should use explicit tool when provided', () => {
+        const result = resolveDelegation({
+            agentRole: 'explore',
+            explicitTool: 'ask_gemini',
+            config: { enabled: true, roles: { explore: { provider: 'codex', tool: 'ask_codex', model: 'gpt-5' } } }
+        });
+        expect(result.tool).toBe('ask_gemini');
+        expect(result.provider).toBe('gemini');
+    });
+    // Test 2: Config roles are respected
+    it('should use configured route when no explicit tool', () => {
+        const result = resolveDelegation({
+            agentRole: 'explore',
+            config: {
+                enabled: true,
+                roles: { explore: { provider: 'gemini', tool: 'ask_gemini', model: 'gemini-3-flash' } }
+            }
+        });
+        expect(result.provider).toBe('gemini');
+        expect(result.tool).toBe('ask_gemini');
+        expect(result.agentOrModel).toBe('gemini-3-flash');
+    });
+    // Test 3: Disabled routing falls back to defaults
+    it('should use default when routing is disabled', () => {
+        const result = resolveDelegation({
+            agentRole: 'explore',
+            config: { enabled: false, roles: { explore: { provider: 'gemini', tool: 'ask_gemini', model: 'flash' } } }
+        });
+        expect(result.provider).toBe('claude');
+        expect(result.tool).toBe('Task');
+    });
+    // Test 4: Unknown roles use defaults
+    it('should handle unknown roles with defaults', () => {
+        const result = resolveDelegation({
+            agentRole: 'unknown-role',
+            config: { enabled: true, defaultProvider: 'codex' }
+        });
+        expect(result.provider).toBe('codex');
+        expect(result.tool).toBe('ask_codex');
+        expect(result.agentOrModel).toBe('gpt-5.3-codex');
+        expect(result.reason).toContain('Fallback to default provider');
+    });
+    // Test 5: Empty config uses defaults
+    it('should use defaults when config is empty', () => {
+        const result = resolveDelegation({ agentRole: 'architect' });
+        expect(result.provider).toBe('claude');
+        expect(result.tool).toBe('Task');
+        expect(result.agentOrModel).toBe('architect');
+    });
+    // Test 6: Explicit ask_codex tool
+    it('should resolve ask_codex explicit tool with default model', () => {
+        const result = resolveDelegation({
+            agentRole: 'explore',
+            explicitTool: 'ask_codex'
+        });
+        expect(result.provider).toBe('codex');
+        expect(result.tool).toBe('ask_codex');
+        expect(result.agentOrModel).toBe('gpt-5.3-codex');
+        expect(result.reason).toContain('Explicit tool invocation');
+    });
+    // Test 7: Explicit ask_codex with custom model
+    it('should resolve ask_codex explicit tool with custom model', () => {
+        const result = resolveDelegation({
+            agentRole: 'explore',
+            explicitTool: 'ask_codex',
+            explicitModel: 'gpt-custom'
+        });
+        expect(result.provider).toBe('codex');
+        expect(result.tool).toBe('ask_codex');
+        expect(result.agentOrModel).toBe('gpt-custom');
+    });
+    // Test 8: Explicit ask_gemini with default model
+    it('should resolve ask_gemini explicit tool with default model', () => {
+        const result = resolveDelegation({
+            agentRole: 'explore',
+            explicitTool: 'ask_gemini'
+        });
+        expect(result.provider).toBe('gemini');
+        expect(result.tool).toBe('ask_gemini');
+        expect(result.agentOrModel).toBe('gemini-3-pro-preview');
+    });
+    // Test 9: Explicit ask_gemini with custom model
+    it('should resolve ask_gemini explicit tool with custom model', () => {
+        const result = resolveDelegation({
+            agentRole: 'explore',
+            explicitTool: 'ask_gemini',
+            explicitModel: 'gemini-custom'
+        });
+        expect(result.provider).toBe('gemini');
+        expect(result.tool).toBe('ask_gemini');
+        expect(result.agentOrModel).toBe('gemini-custom');
+    });
+    // Test 10: Explicit Task tool
+    it('should resolve Task explicit tool', () => {
+        const result = resolveDelegation({
+            agentRole: 'architect',
+            explicitTool: 'Task'
+        });
+        expect(result.provider).toBe('claude');
+        expect(result.tool).toBe('Task');
+        expect(result.agentOrModel).toBe('architect');
+    });
+    // Test 11: Explicit tool takes precedence over enabled config for same role
+    it('should have explicit tool take precedence over enabled config for same role', () => {
+        const result = resolveDelegation({
+            agentRole: 'explore',
+            explicitTool: 'ask_codex',
+            config: {
+                enabled: true,
+                roles: {
+                    explore: { provider: 'gemini', tool: 'ask_gemini', model: 'gemini-3-flash' }
+                }
+            }
+        });
+        expect(result.provider).toBe('codex');
+        expect(result.tool).toBe('ask_codex');
+        expect(result.reason).toContain('Explicit tool invocation');
+    });
+    // Test 12: Role with default mapping uses Claude subagent
+    it('should use default heuristic for mapped roles', () => {
+        const result = resolveDelegation({
+            agentRole: 'executor',
+            config: { enabled: true, roles: {} }
+        });
+        expect(result.provider).toBe('claude');
+        expect(result.tool).toBe('Task');
+        expect(result.agentOrModel).toBe('executor');
+        expect(result.reason).toContain('Default heuristic');
+    });
+    // Test 12: Config with agentType instead of model
+    it('should use agentType when model is not specified', () => {
+        const result = resolveDelegation({
+            agentRole: 'custom-role',
+            config: {
+                enabled: true,
+                roles: {
+                    'custom-role': { provider: 'claude', tool: 'Task', agentType: 'explore' }
+                }
+            }
+        });
+        expect(result.agentOrModel).toBe('explore');
+    });
+    // Test 13: Config with fallback chain
+    it('should include fallback chain in decision', () => {
+        const result = resolveDelegation({
+            agentRole: 'explore',
+            config: {
+                enabled: true,
+                roles: {
+                    explore: {
+                        provider: 'gemini',
+                        tool: 'ask_gemini',
+                        model: 'gemini-2.5-pro',
+                        fallback: ['claude:explore', 'codex:gpt-5']
+                    }
+                }
+            }
+        });
+        expect(result.provider).toBe('gemini');
+        expect(result.tool).toBe('ask_gemini');
+        expect(result.agentOrModel).toBe('gemini-2.5-pro');
+        expect(result.reason).toContain('Configured routing');
+        expect(result.fallbackChain).toEqual(['claude:explore', 'codex:gpt-5']);
+    });
+    // Test 14: defaultProvider set to gemini
+    it('should use gemini as default provider when configured', () => {
+        const result = resolveDelegation({
+            agentRole: 'unknown-role',
+            config: { enabled: true, defaultProvider: 'gemini' }
+        });
+        expect(result.provider).toBe('gemini');
+        expect(result.tool).toBe('ask_gemini');
+        expect(result.agentOrModel).toBe('gemini-3-pro-preview');
+    });
+    // Test 15: Config enabled but role not in roles map
+    it('should fallback to defaults when role not in config roles', () => {
+        const result = resolveDelegation({
+            agentRole: 'nonexistent-role',
+            config: {
+                enabled: true,
+                roles: { explore: { provider: 'gemini', tool: 'ask_gemini', model: 'flash' } }
+            }
+        });
+        expect(result.provider).toBe('claude');
+        expect(result.tool).toBe('Task');
+        expect(result.agentOrModel).toBe('nonexistent-role');
+        expect(result.reason).toContain('Fallback to Claude Task');
+    });
+    // Test 16: Config explicitly enabled undefined (should be treated as disabled)
+    it('should treat undefined enabled as disabled', () => {
+        const result = resolveDelegation({
+            agentRole: 'explore',
+            config: {
+                roles: { explore: { provider: 'gemini', tool: 'ask_gemini', model: 'flash' } }
+            }
+        });
+        // When enabled is undefined, isDelegationEnabled returns false
+        expect(result.provider).toBe('claude');
+        expect(result.tool).toBe('Task');
+        expect(result.agentOrModel).toBe('explore');
+        expect(result.reason).toContain('Default heuristic');
+    });
+    // Test 17: Empty roles object with enabled true
+    it('should use defaults when roles object is empty', () => {
+        const result = resolveDelegation({
+            agentRole: 'architect',
+            config: { enabled: true, roles: {} }
+        });
+        expect(result.provider).toBe('claude');
+        expect(result.tool).toBe('Task');
+        expect(result.agentOrModel).toBe('architect');
+        expect(result.reason).toContain('Default heuristic');
+    });
+    // Test 18: All known role categories use defaults correctly
+    it.each([
+        ['explore', 'explore'],
+        ['document-specialist', 'document-specialist'],
+        ['researcher', 'researcher'],
+        ['architect', 'architect'],
+        ['planner', 'planner'],
+        ['critic', 'critic'],
+        ['analyst', 'analyst'],
+        ['executor', 'executor'],
+        ['deep-executor', 'deep-executor'],
+        ['code-reviewer', 'code-reviewer'],
+        ['security-reviewer', 'security-reviewer'],
+        ['quality-reviewer', 'quality-reviewer'],
+        ['designer', 'designer'],
+        ['writer', 'writer'],
+        ['vision', 'vision'],
+        ['qa-tester', 'qa-tester'],
+        ['debugger', 'debugger'],
+        ['scientist', 'scientist'],
+        ['build-fixer', 'build-fixer'],
+    ])('should map role %s to default agent %s', (role, expectedAgent) => {
+        const result = resolveDelegation({ agentRole: role });
+        expect(result.agentOrModel).toBe(expectedAgent);
+        expect(result.provider).toBe('claude');
+    });
+    // Test 19: Undefined config
+    it('should handle undefined config gracefully', () => {
+        const result = resolveDelegation({
+            agentRole: 'explore',
+            config: undefined
+        });
+        expect(result.provider).toBe('claude');
+        expect(result.tool).toBe('Task');
+    });
+    // Test 20: Config with model and agentType - model takes precedence
+    it('should prefer model over agentType when both specified', () => {
+        const result = resolveDelegation({
+            agentRole: 'custom-role',
+            config: {
+                enabled: true,
+                roles: {
+                    'custom-role': {
+                        provider: 'claude',
+                        tool: 'Task',
+                        model: 'custom-model',
+                        agentType: 'explore'
+                    }
+                }
+            }
+        });
+        expect(result.agentOrModel).toBe('custom-model');
+    });
+    // Test: Provider/tool mismatch logs warning
+    it('should log warning when provider/tool mismatch is corrected', () => {
+        resolveDelegation({
+            agentRole: 'test-role',
+            config: {
+                enabled: true,
+                roles: {
+                    'test-role': { provider: 'claude', tool: 'ask_codex', model: 'test' }
+                }
+            }
+        });
+        expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('Provider/tool mismatch'));
+        expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('claude'));
+        expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('ask_codex'));
+    });
+    // Test: Unknown role + defaultProvider: 'gemini' with full assertion
+    it('should handle unknown role with gemini defaultProvider', () => {
+        const result = resolveDelegation({
+            agentRole: 'totally-unknown-role',
+            config: { enabled: true, defaultProvider: 'gemini' }
+        });
+        expect(result.provider).toBe('gemini');
+        expect(result.tool).toBe('ask_gemini');
+        expect(result.agentOrModel).toBe('gemini-3-pro-preview');
+        expect(result.reason).toContain('Fallback to default provider: gemini');
+        expect(result.fallbackChain).toBeUndefined();
+    });
+    // Test: Unknown role + defaultProvider: 'codex' with full assertion
+    it('should handle unknown role with codex defaultProvider', () => {
+        const result = resolveDelegation({
+            agentRole: 'totally-unknown-role',
+            config: { enabled: true, defaultProvider: 'codex' }
+        });
+        expect(result.provider).toBe('codex');
+        expect(result.tool).toBe('ask_codex');
+        expect(result.agentOrModel).toBe('gpt-5.3-codex');
+        expect(result.reason).toContain('Fallback to default provider: codex');
+        expect(result.fallbackChain).toBeUndefined();
+    });
+    // Test: Unknown role + defaultProvider: 'claude' (explicit) with full assertion
+    it('should handle unknown role with claude defaultProvider', () => {
+        const result = resolveDelegation({
+            agentRole: 'totally-unknown-role',
+            config: { enabled: true, defaultProvider: 'claude' }
+        });
+        expect(result.provider).toBe('claude');
+        expect(result.tool).toBe('Task');
+        expect(result.agentOrModel).toBe('totally-unknown-role');
+        expect(result.reason).toContain('Fallback to Claude Task');
+        expect(result.fallbackChain).toBeUndefined();
+    });
+    // Test: Known role + defaultProvider (should use heuristic, not defaultProvider)
+    it('should use heuristic for known role even with different defaultProvider', () => {
+        const result = resolveDelegation({
+            agentRole: 'architect',
+            config: { enabled: true, defaultProvider: 'gemini' }
+        });
+        // architect is in ROLE_CATEGORY_DEFAULTS, so should use Claude subagent
+        expect(result.provider).toBe('claude');
+        expect(result.tool).toBe('Task');
+        expect(result.agentOrModel).toBe('architect');
+        expect(result.reason).toContain('Default heuristic');
+    });
+});
+describe('parseFallbackChain', () => {
+    it('should parse valid fallback strings', () => {
+        const result = parseFallbackChain(['claude:explore', 'codex:gpt-5']);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toEqual({ provider: 'claude', agentOrModel: 'explore' });
+        expect(result[1]).toEqual({ provider: 'codex', agentOrModel: 'gpt-5' });
+    });
+    it('should return empty array for undefined input', () => {
+        expect(parseFallbackChain(undefined)).toEqual([]);
+    });
+    it('should return empty array for empty array input', () => {
+        expect(parseFallbackChain([])).toEqual([]);
+    });
+    it('should handle fallback strings with multiple colons', () => {
+        const result = parseFallbackChain(['codex:gpt-5.3-codex', 'gemini:gemini-2.5-pro']);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toEqual({ provider: 'codex', agentOrModel: 'gpt-5.3-codex' });
+        expect(result[1]).toEqual({ provider: 'gemini', agentOrModel: 'gemini-2.5-pro' });
+    });
+    it('should skip invalid entries without colon', () => {
+        const result = parseFallbackChain(['claude:explore', 'invalid-entry', 'codex:gpt-5']);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toEqual({ provider: 'claude', agentOrModel: 'explore' });
+        expect(result[1]).toEqual({ provider: 'codex', agentOrModel: 'gpt-5' });
+    });
+    it('should skip entries with empty provider', () => {
+        const result = parseFallbackChain([':explore', 'codex:gpt-5']);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual({ provider: 'codex', agentOrModel: 'gpt-5' });
+    });
+    it('should skip entries with empty agent/model', () => {
+        const result = parseFallbackChain(['claude:', 'codex:gpt-5']);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual({ provider: 'codex', agentOrModel: 'gpt-5' });
+    });
+    it('should handle single valid entry', () => {
+        const result = parseFallbackChain(['gemini:gemini-2.5-pro']);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual({ provider: 'gemini', agentOrModel: 'gemini-2.5-pro' });
+    });
+    it('should handle all invalid entries', () => {
+        const result = parseFallbackChain(['invalid', 'another-invalid', '']);
+        expect(result).toEqual([]);
+    });
+    it('should preserve case sensitivity', () => {
+        const result = parseFallbackChain(['Claude:Explore', 'CODEX:GPT-5']);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toEqual({ provider: 'Claude', agentOrModel: 'Explore' });
+        expect(result[1]).toEqual({ provider: 'CODEX', agentOrModel: 'GPT-5' });
+    });
+    it('should handle entries with extra whitespace in model name', () => {
+        const result = parseFallbackChain(['claude: explore with spaces']);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual({ provider: 'claude', agentOrModel: 'explore with spaces' });
+    });
+    it('should trim whitespace from fallback entries', () => {
+        const result = parseFallbackChain(['  claude  :  explore  ', '  codex  :  gpt-5  ']);
+        expect(result).toHaveLength(2);
+        expect(result[0]).toEqual({ provider: 'claude', agentOrModel: 'explore' });
+        expect(result[1]).toEqual({ provider: 'codex', agentOrModel: 'gpt-5' });
+    });
+});
+describe('resolveDelegation provider/tool mismatch correction', () => {
+    it('should correct provider/tool mismatch', () => {
+        const result = resolveDelegation({
+            agentRole: 'test-role',
+            config: {
+                enabled: true,
+                roles: {
+                    'test-role': { provider: 'claude', tool: 'ask_codex', model: 'test' } // Invalid: claude should use Task
+                }
+            }
+        });
+        expect(result.provider).toBe('claude');
+        expect(result.tool).toBe('Task'); // Should be corrected
+    });
+});
+//# sourceMappingURL=resolver.test.js.map