vibeman 0.0.1 → 0.0.3

package/dist/runtime/api/agent/prompt-service.js

@@ -70,8 +70,11 @@ If you recommend changes to type or priority, include them at the top of your re
 Return a JSON object with:
 - "type": one of [feature, bug, chore, refactor, test, doc]
 - "priority": one of [high, medium, low]
+- "title": a concise, descriptive title for the task (optional, but preferred)
 - "content": the improved task specification in markdown format with proper JSON escaping
 
+If you include a title in the JSON response, do NOT include an H1 heading at the beginning of the content field to avoid duplication.
+
 ## Project Context
 
 <ProjectContext>
@@ -95,6 +98,10 @@ const TASK_TEMPLATE = `## Task Assignment
 
 Deliver the following task.
 
+## Workflow Instructions
+
+{{workflowInstructions}}
+
 ## Responsibilities
 
 1. **Analyze requirements** — study the acceptance criteria to clarify what must be delivered.
@@ -132,6 +139,8 @@ Begin by examining the codebase; then proceed with the implementation.
 - **Status:** {{taskStatus}}
 - **Tags:** {{tagsList}}
 
+{{taskFilePathInfo}}
+
 #### Description
 
 {{taskContent}}
@@ -155,7 +164,7 @@ If conflicts:
 `;
 const REVIEW_TEMPLATE = `## Code Review Task
 
-Review the changes made for this task comprehensively.
+Review the changes made for this task comprehensively. Return a JSON string with Fenced JSON.
 
 1. **Analyze the implemented changes** by examining the modified files, some of them might be committed in the recent commits
 2. **Evaluate code quality** including:
@@ -171,17 +180,17 @@ Review the changes made for this task comprehensively.
   - Implementation matches the task requirements
   - No unrelated changes were introduced
 
-4. **Provide structured feedback** using this JSON structure:
+4. **Provide structured feedback** using this JSON structure with following fields:
+
+
+"reviewSummary": "Brief overview of the implementation and overall assessment",
+"recommendations": [
+  "Specific recommendation 1",
+  "Specific recommendation 2",
+  "Specific recommendation 3"
+],
+"qualityScore": 85
 
-{
-  "reviewSummary": "Brief overview of the implementation and overall assessment",
-  "recommendations": [
-    "Specific recommendation 1",
-    "Specific recommendation 2",
-    "Specific recommendation 3"
-  ],
-  "qualityScore": 85
-}
 
 ## Review Guidelines
 
@@ -194,7 +203,7 @@ Review the changes made for this task comprehensively.
   - Testing & coverage: 0-20
   - Security & performance considerations: 0-15
 
-If you identify any critical bugs or potential improvements, provide detailed notes, accpetance criteria, implementation details, todo list, etc. in the Recommendations section and return a score below 70. This will trigger a reimplementation based on your feedback.
+If you identify any critical bugs or potential improvements, provide detailed notes, acceptance criteria, implementation details, todo list, etc. in the Recommendations section and return a score below 70. This will trigger a reimplementation based on your feedback.
 
 ---
 
@@ -258,6 +267,32 @@ export class PromptService {
         this.projectRoot = projectRoot;
         this.taskService = taskService;
     }
+    /**
+     * Generate absolute path to task file
+     */
+    generateTaskFilePath(taskId) {
+        try {
+            const vibeDir = getVibeDir();
+            const taskFilePath = path.resolve(vibeDir, 'tasks', `${taskId}.md`);
+            return taskFilePath;
+        }
+        catch (error) {
+            log.error(`Failed to generate task file path for ${taskId}`, error, 'prompt-service');
+            return null;
+        }
+    }
+    /**
+     * Validate that task file exists at the given path
+     */
+    async validateTaskFile(filePath) {
+        try {
+            await fs.access(filePath, fs.constants.F_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async generateImprovementPrompt(task, taskData) {
         // Read project context
         const productOverviewPath = path.join(getVibeDir(), 'product_overview.md');
@@ -268,6 +303,12 @@ export class PromptService {
         catch {
             log.warn('Could not read product_overview.md for improvement prompt', undefined, 'prompt-service');
         }
+        // Add task file path to project context for improvement prompts
+        const taskFilePath = this.generateTaskFilePath(task.id);
+        if (taskFilePath && (await this.validateTaskFile(taskFilePath))) {
+            productContext += `\n\n**Current task file location:** ${taskFilePath}`;
+            log.info(`Task file path included in improvement prompt`, { taskId: task.id, path: taskFilePath }, 'prompt-service');
+        }
         return render(IMPROVEMENT_TEMPLATE, {
             projectContext: productContext,
             taskId: task.id,
@@ -278,8 +319,28 @@ export class PromptService {
             taskContent: taskData.content,
         });
     }
-    async generateTaskPrompt(task) {
+    async generateTaskPrompt(task, workflowConfig) {
         const tagsList = task.tags.join(', ');
+        // Generate and validate task file path
+        const taskFilePath = this.generateTaskFilePath(task.id);
+        let taskFilePathInfo = '';
+        if (taskFilePath) {
+            const isValid = await this.validateTaskFile(taskFilePath);
+            if (isValid) {
+                taskFilePathInfo = `- **Current task file:** ${taskFilePath}`;
+                log.info(`Task file path included in prompt`, { taskId: task.id, path: taskFilePath }, 'prompt-service');
+            }
+            else {
+                taskFilePathInfo = `- **Task file:** (not accessible at expected path: ${taskFilePath})`;
+                log.warn(`Task file not accessible`, { taskId: task.id, path: taskFilePath }, 'prompt-service');
+            }
+        }
+        else {
+            taskFilePathInfo = `- **Task file:** (path could not be resolved)`;
+            log.error(`Could not generate task file path`, { taskId: task.id }, 'prompt-service');
+        }
+        // Build workflow instruction prompts based on workflow configuration
+        const workflowInstructions = this.buildWorkflowInstructions(workflowConfig);
         return render(TASK_TEMPLATE, {
             taskId: task.id,
             taskTitle: task.title,
@@ -288,8 +349,50 @@ export class PromptService {
             taskStatus: task.status,
             taskContent: task.content,
             tagsList,
+            taskFilePathInfo,
+            workflowInstructions,
         });
     }
+    /**
+     * Build a prominent, clearly formatted instruction section derived from workflow options.
+     * If no options are provided or none apply, returns a minimal guidance line.
+     */
+    buildWorkflowInstructions(cfg) {
+        const lines = [];
+        if (!cfg) {
+            // Default lightweight guidance when workflow config is unavailable
+            return '- Follow project conventions and ask before destructive actions.';
+        }
+        // Auto Commit disabled prompt
+        if (cfg.autoCommit === false) {
+            lines.push('IMPORTANT: AUTO COMMIT IS DISABLED');
+            lines.push('- DO NOT commit any changes');
+            lines.push('- DO NOT run git commit commands');
+            lines.push('- Leave all changes staged for manual review');
+            lines.push('');
+        }
+        // PR creation disabled prompt
+        if (cfg.createPR === false) {
+            lines.push('IMPORTANT: PR CREATION IS DISABLED');
+            lines.push('- DO NOT create pull requests');
+            lines.push('- DO NOT run gh pr create commands');
+            lines.push('- Prepare changes for manual PR creation');
+            lines.push('');
+        }
+        // Auto merge disabled prompt
+        if (cfg.autoMerge === false) {
+            lines.push('IMPORTANT: AUTO MERGE IS DISABLED');
+            lines.push('- DO NOT merge pull requests automatically');
+            lines.push('- DO NOT run git merge commands');
+            lines.push('- Prepare changes for manual merge approval');
+            lines.push('');
+        }
+        // If nothing matched, provide a simple fallback
+        if (lines.length === 0) {
+            return '- No special workflow constraints. Proceed with standard process.';
+        }
+        return lines.join('\n');
+    }
     async generateAIMergePrompt(task, worktree, baseBranch) {
         const repoPath = this.projectRoot;
         const featureBr = worktree.branchName;
@@ -321,7 +424,13 @@ export class PromptService {
         });
     }
     async generateReviewPrompt(task, worktree, reviewContext) {
-        const additionalContext = reviewContext ? `\n**Additional Context:** ${reviewContext}` : '';
+        let additionalContext = reviewContext ? `\n**Additional Context:** ${reviewContext}` : '';
+        // Add task file path to additional context
+        const taskFilePath = this.generateTaskFilePath(task.id);
+        if (taskFilePath && (await this.validateTaskFile(taskFilePath))) {
+            additionalContext += `\n**Current task file:** ${taskFilePath}`;
+            log.info(`Task file path included in review prompt`, { taskId: task.id, path: taskFilePath }, 'prompt-service');
+        }
         return render(REVIEW_TEMPLATE, {
             taskId: task.id,
             taskTitle: task.title,

package/dist/runtime/api/agent/prompt-service.test.js

@@ -0,0 +1,230 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { PromptService } from './prompt-service.js';
+const TEST_DATA_DIR = path.resolve(process.cwd(), '.test-prompt-service');
+const TEST_TASKS_DIR = path.join(TEST_DATA_DIR, 'tasks');
+// Mock getVibeDir to return test directory
+vi.mock('../lib/server/project-root', () => ({
+    getVibeDir: () => TEST_DATA_DIR,
+    getProjectRoot: () => TEST_DATA_DIR,
+}));
+// Mock TaskService
+const mockTaskService = {
+    getTask: vi.fn(),
+    getAllTasks: vi.fn(),
+};
+describe('PromptService Task File Path Integration', () => {
+    let promptService;
+    beforeEach(async () => {
+        promptService = new PromptService(TEST_DATA_DIR, mockTaskService);
+        // Create test directories
+        await fs.mkdir(TEST_TASKS_DIR, { recursive: true });
+    });
+    afterEach(async () => {
+        // Clean up test data
+        try {
+            await fs.rm(TEST_DATA_DIR, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    describe('generateTaskPrompt', () => {
+        it('should include absolute path when task file exists', async () => {
+            const mockTask = {
+                id: 'TEST-TASK-001',
+                title: 'Test Task',
+                type: 'feature',
+                status: 'in-progress',
+                priority: 'high',
+                tags: ['test'],
+                content: 'Test task content',
+                created_at: '2024-09-04T12:00:00.000Z',
+                updated_at: '2024-09-04T12:00:00.000Z',
+                assignee: [],
+                comments: [],
+            };
+            // Create task file
+            const taskFilePath = path.join(TEST_TASKS_DIR, 'TEST-TASK-001.md');
+            const taskFileContent = `---
+id: TEST-TASK-001
+title: Test Task
+type: feature
+status: in-progress
+priority: high
+tags: test
+---
+
+Test task content`;
+            await fs.writeFile(taskFilePath, taskFileContent, 'utf-8');
+            const prompt = await promptService.generateTaskPrompt(mockTask);
+            expect(prompt).toContain('Current task file:');
+            expect(prompt).toContain(taskFilePath);
+            expect(prompt).toContain('TEST-TASK-001');
+            expect(prompt).toContain('Test Task');
+            expect(prompt).toContain('Test task content');
+        });
+        it('should handle missing task file gracefully', async () => {
+            const mockTask = {
+                id: 'NONEXISTENT-TASK',
+                title: 'Nonexistent Task',
+                type: 'bug',
+                status: 'backlog',
+                priority: 'medium',
+                tags: [],
+                content: 'This task file does not exist',
+                created_at: '2024-09-04T12:00:00.000Z',
+                updated_at: '2024-09-04T12:00:00.000Z',
+                assignee: [],
+                comments: [],
+            };
+            const prompt = await promptService.generateTaskPrompt(mockTask);
+            expect(prompt).toContain('not accessible at expected path');
+            expect(prompt).toContain('NONEXISTENT-TASK.md');
+            expect(prompt).toContain('Nonexistent Task');
+            expect(prompt).toContain('This task file does not exist');
+        });
+        it('should handle path resolution errors', async () => {
+            // Mock generateTaskFilePath to return null (simulating path resolution error)
+            const originalGenerateTaskFilePath = promptService.generateTaskFilePath;
+            promptService.generateTaskFilePath = vi.fn().mockReturnValue(null);
+            const mockTask = {
+                id: 'ERROR-TASK',
+                title: 'Error Task',
+                type: 'chore',
+                status: 'review',
+                priority: 'low',
+                tags: ['error'],
+                content: 'Task with path resolution error',
+                created_at: '2024-09-04T12:00:00.000Z',
+                updated_at: '2024-09-04T12:00:00.000Z',
+                assignee: [],
+                comments: [],
+            };
+            const prompt = await promptService.generateTaskPrompt(mockTask);
+            expect(prompt).toContain('path could not be resolved');
+            expect(prompt).toContain('ERROR-TASK');
+            expect(prompt).toContain('Task with path resolution error');
+            // Restore original method
+            promptService.generateTaskFilePath = originalGenerateTaskFilePath;
+        });
+    });
+    describe('generateImprovementPrompt', () => {
+        it('should include task file path in project context', async () => {
+            const mockTask = {
+                id: 'IMPROVE-TASK-001',
+                title: 'Improvement Task',
+                type: 'feature',
+                status: 'backlog',
+                priority: 'medium',
+                tags: [],
+                content: 'Original content',
+                created_at: '2024-09-04T12:00:00.000Z',
+                updated_at: '2024-09-04T12:00:00.000Z',
+                assignee: [],
+                comments: [],
+            };
+            const taskData = {
+                title: 'Improved Task',
+                type: 'feature',
+                priority: 'high',
+                content: 'Improved content',
+            };
+            // Create task file
+            const taskFilePath = path.join(TEST_TASKS_DIR, 'IMPROVE-TASK-001.md');
+            await fs.writeFile(taskFilePath, 'Task file content', 'utf-8');
+            const prompt = await promptService.generateImprovementPrompt(mockTask, taskData);
+            expect(prompt).toContain('Current task file location:');
+            expect(prompt).toContain(taskFilePath);
+            expect(prompt).toContain('IMPROVE-TASK-001');
+        });
+    });
+    describe('generateReviewPrompt', () => {
+        it('should include task file path in additional context', async () => {
+            const mockTask = {
+                id: 'REVIEW-TASK-001',
+                title: 'Review Task',
+                type: 'bug',
+                status: 'review',
+                priority: 'high',
+                tags: [],
+                content: 'Task under review',
+                created_at: '2024-09-04T12:00:00.000Z',
+                updated_at: '2024-09-04T12:00:00.000Z',
+                assignee: [],
+                comments: [],
+            };
+            const mockWorktree = {
+                taskId: 'REVIEW-TASK-001',
+                path: '/test/worktree',
+                branchName: 'feature/review-task-001',
+            };
+            // Create task file
+            const taskFilePath = path.join(TEST_TASKS_DIR, 'REVIEW-TASK-001.md');
+            await fs.writeFile(taskFilePath, 'Review task content', 'utf-8');
+            const prompt = await promptService.generateReviewPrompt(mockTask, mockWorktree, 'Custom review context');
+            expect(prompt).toContain('Current task file:');
+            expect(prompt).toContain(taskFilePath);
+            expect(prompt).toContain('Custom review context');
+            expect(prompt).toContain('REVIEW-TASK-001');
+        });
+    });
+    describe('cross-platform path resolution', () => {
+        it('should generate valid absolute paths on different platforms', async () => {
+            const taskId = 'CROSS-PLATFORM-TEST';
+            // Test the private method through a task prompt generation
+            const mockTask = {
+                id: taskId,
+                title: 'Cross Platform Test',
+                type: 'test',
+                status: 'in-progress',
+                priority: 'medium',
+                tags: [],
+                content: 'Cross platform path test',
+                created_at: '2024-09-04T12:00:00.000Z',
+                updated_at: '2024-09-04T12:00:00.000Z',
+                assignee: [],
+                comments: [],
+            };
+            // Create task file
+            const taskFilePath = path.join(TEST_TASKS_DIR, `${taskId}.md`);
+            await fs.writeFile(taskFilePath, 'Cross platform test content', 'utf-8');
+            const prompt = await promptService.generateTaskPrompt(mockTask);
+            // Verify the path is absolute and uses correct separators
+            const pathMatch = prompt.match(/- \*\*Current task file:\*\* (.+)/);
+            expect(pathMatch).toBeTruthy();
+            if (pathMatch) {
+                const extractedPath = pathMatch[1];
+                expect(path.isAbsolute(extractedPath)).toBe(true);
+                expect(extractedPath).toContain(taskId);
+                expect(extractedPath.endsWith('.md')).toBe(true);
+            }
+        });
+    });
+    describe('error handling', () => {
+        it('should handle file system permission errors gracefully', async () => {
+            const mockTask = {
+                id: 'PERMISSION-TEST',
+                title: 'Permission Test',
+                type: 'chore',
+                status: 'backlog',
+                priority: 'low',
+                tags: [],
+                content: 'Permission test content',
+                created_at: '2024-09-04T12:00:00.000Z',
+                updated_at: '2024-09-04T12:00:00.000Z',
+                assignee: [],
+                comments: [],
+            };
+            // Mock validateTaskFile to simulate permission error
+            const originalValidateTaskFile = promptService.validateTaskFile;
+            promptService.validateTaskFile = vi.fn().mockResolvedValueOnce(false);
+            const prompt = await promptService.generateTaskPrompt(mockTask);
+            expect(prompt).toContain('not accessible at expected path');
+            expect(prompt).toContain('PERMISSION-TEST');
+            // Restore original function
+            promptService.validateTaskFile = originalValidateTaskFile;
+        });
+    });
+});

package/dist/runtime/api/agent/routing-policy.d.ts

@@ -6,7 +6,8 @@ import { z } from 'zod';
 /**
  * Operation types that support AI routing
  */
-export type RoutableOperation = 'execute_task' | 'improve_task' | 'ai_codereview' | 'ai_merge';
+declare const ROUTABLE_OPERATIONS: readonly ["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"];
+export type RoutableOperation = (typeof ROUTABLE_OPERATIONS)[number];
 /**
  * Generation options for AI execution
  */
@@ -15,13 +16,13 @@ export declare const GenerationOptionsSchema: z.ZodObject<{
     maxTokens: z.ZodOptional<z.ZodNumber>;
     tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
+    temperature?: number | undefined;
     maxTokens?: number | undefined;
     tools?: string[] | undefined;
-    temperature?: number | undefined;
 }, {
+    temperature?: number | undefined;
     maxTokens?: number | undefined;
     tools?: string[] | undefined;
-    temperature?: number | undefined;
 }>;
 export type GenerationOptions = z.infer<typeof GenerationOptionsSchema>;
 /**
@@ -35,30 +36,30 @@ export declare const OperationConfigSchema: z.ZodObject<{
         maxTokens: z.ZodOptional<z.ZodNumber>;
         tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
+        temperature?: number | undefined;
         maxTokens?: number | undefined;
         tools?: string[] | undefined;
-        temperature?: number | undefined;
     }, {
+        temperature?: number | undefined;
         maxTokens?: number | undefined;
         tools?: string[] | undefined;
-        temperature?: number | undefined;
     }>>;
     fallback: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     provider: string;
     options?: {
+        temperature?: number | undefined;
         maxTokens?: number | undefined;
         tools?: string[] | undefined;
-        temperature?: number | undefined;
     } | undefined;
     model?: string | undefined;
     fallback?: string[] | undefined;
 }, {
     provider: string;
     options?: {
+        temperature?: number | undefined;
         maxTokens?: number | undefined;
         tools?: string[] | undefined;
-        temperature?: number | undefined;
     } | undefined;
     model?: string | undefined;
     fallback?: string[] | undefined;
@@ -69,7 +70,7 @@ export type OperationConfig = z.infer<typeof OperationConfigSchema>;
  */
 export declare const RoutingPolicySchema: z.ZodObject<{
     defaultProvider: z.ZodString;
-    operations: z.ZodOptional<z.ZodRecord<z.ZodEnum<["execute_task", "improve_task", "ai_codereview", "ai_merge"]>, z.ZodObject<{
+    operations: z.ZodOptional<z.ZodRecord<z.ZodEnum<["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"]>, z.ZodObject<{
         provider: z.ZodString;
         model: z.ZodOptional<z.ZodString>;
         options: z.ZodOptional<z.ZodObject<{
@@ -77,60 +78,61 @@ export declare const RoutingPolicySchema: z.ZodObject<{
             maxTokens: z.ZodOptional<z.ZodNumber>;
             tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "strip", z.ZodTypeAny, {
+            temperature?: number | undefined;
             maxTokens?: number | undefined;
             tools?: string[] | undefined;
-            temperature?: number | undefined;
         }, {
+            temperature?: number | undefined;
             maxTokens?: number | undefined;
             tools?: string[] | undefined;
-            temperature?: number | undefined;
         }>>;
         fallback: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         provider: string;
         options?: {
+            temperature?: number | undefined;
             maxTokens?: number | undefined;
             tools?: string[] | undefined;
-            temperature?: number | undefined;
         } | undefined;
         model?: string | undefined;
         fallback?: string[] | undefined;
     }, {
         provider: string;
         options?: {
+            temperature?: number | undefined;
             maxTokens?: number | undefined;
             tools?: string[] | undefined;
-            temperature?: number | undefined;
         } | undefined;
         model?: string | undefined;
         fallback?: string[] | undefined;
     }>>>;
 }, "strip", z.ZodTypeAny, {
     defaultProvider: string;
-    operations?: Partial<Record<"execute_task" | "improve_task" | "ai_codereview" | "ai_merge", {
+    operations?: Partial<Record<"execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview", {
         provider: string;
         options?: {
+            temperature?: number | undefined;
             maxTokens?: number | undefined;
             tools?: string[] | undefined;
-            temperature?: number | undefined;
         } | undefined;
         model?: string | undefined;
         fallback?: string[] | undefined;
     }>> | undefined;
 }, {
     defaultProvider: string;
-    operations?: Partial<Record<"execute_task" | "improve_task" | "ai_codereview" | "ai_merge", {
+    operations?: Partial<Record<"execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview", {
         provider: string;
         options?: {
+            temperature?: number | undefined;
             maxTokens?: number | undefined;
             tools?: string[] | undefined;
-            temperature?: number | undefined;
         } | undefined;
         model?: string | undefined;
         fallback?: string[] | undefined;
     }>> | undefined;
 }>;
 export type RoutingPolicy = z.infer<typeof RoutingPolicySchema>;
+export declare const ROUTABLE_OPERATION_LIST: readonly ["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"];
 /**
  * Resolved provider configuration for execution
  */
@@ -142,47 +144,28 @@ export interface ResolvedProvider {
 }
 /**
  * Routing Policy Manager
- * Manages AI provider routing policies with hot-reload capability
+ * Manages AI provider routing policies stored inside settings.json
  */
 export declare class RoutingPolicyManager {
     private policy;
-    private policyFilePath;
-    private lastModified;
+    private readonly settingsService;
     constructor();
     /**
-     * Get current effective policy with hot-reload
+     * Get current effective policy (lazy loads from settings)
      */
     getPolicy(): Promise<RoutingPolicy>;
     /**
-     * Update routing policy and persist to disk
+     * Update routing policy and persist via settings service
      */
     updatePolicy(updates: Partial<RoutingPolicy>): Promise<void>;
     /**
      * Resolve provider for a specific operation
      */
+    getEffectivePolicy(): Promise<RoutingPolicy>;
     resolveProviderForOperation(operation: RoutableOperation, overrides?: Partial<ResolvedProvider>): Promise<ResolvedProvider>;
-    /**
-     * Set default provider
-     */
     setDefaultProvider(provider: string): Promise<void>;
-    /**
-     * Set operation-specific routing
-     */
     setOperationConfig(operation: RoutableOperation, config: OperationConfig): Promise<void>;
-    /**
-     * Validate policy against available providers
-     */
     validatePolicy(policy: RoutingPolicy, availableProviders: Set<string>): string[];
-    /**
-     * Load policy from file if it has changed
-     */
-    private loadPolicyIfChanged;
-    /**
-     * Create example policy file if it doesn't exist
-     */
-    createExamplePolicy(): Promise<void>;
-    /**
-     * Get policy file path for external access
-     */
-    getPolicyFilePath(): string;
+    private buildPolicyFromSettings;
 }
+export {};