vibeman 0.0.2 → 0.0.3

package/dist/runtime/api/agent/routing-policy.js

@@ -3,11 +3,18 @@
  * Handles provider selection per operation with fallbacks and configuration
  */
 import { z } from 'zod';
-import fs from 'fs/promises';
-import path from 'path';
 import { log } from '../lib/logger.js';
 import { getSettingsService } from '../settings-service.js';
-import { getVibeDir } from '../lib/server/project-root.js';
+/**
+ * Operation types that support AI routing
+ */
+const ROUTABLE_OPERATIONS = [
+    'execute_task',
+    'quality_checks',
+    'ai_codereview',
+    'ai_merge',
+    'improve_task',
+];
 /**
  * Generation options for AI execution
  */
@@ -30,67 +37,83 @@ export const OperationConfigSchema = z.object({
  */
 export const RoutingPolicySchema = z.object({
     defaultProvider: z.string(),
-    operations: z
-        .record(z.enum(['execute_task', 'improve_task', 'ai_codereview', 'ai_merge']), OperationConfigSchema)
-        .optional(),
+    operations: z.record(z.enum(ROUTABLE_OPERATIONS), OperationConfigSchema).optional(),
 });
+export const ROUTABLE_OPERATION_LIST = ROUTABLE_OPERATIONS;
 /**
  * Routing Policy Manager
- * Manages AI provider routing policies with hot-reload capability
+ * Manages AI provider routing policies stored inside settings.json
  */
 export class RoutingPolicyManager {
     constructor() {
         this.policy = null;
-        this.lastModified = 0;
-        this.policyFilePath = path.join(getVibeDir(), 'ai-routing.json');
+        this.settingsService = getSettingsService();
+        // Invalidate cached policy when settings change
+        this.settingsService.on('settingsUpdated', () => {
+            this.policy = null;
+        });
     }
     /**
-     * Get current effective policy with hot-reload
+     * Get current effective policy (lazy loads from settings)
      */
     async getPolicy() {
-        await this.loadPolicyIfChanged();
-        // Return default policy if none exists
         if (!this.policy) {
-            const settings = getSettingsService().getSettings();
-            return {
-                defaultProvider: settings.agents.defaultProvider || 'claude-code',
-                operations: {},
-            };
+            this.policy = this.buildPolicyFromSettings();
         }
         return this.policy;
     }
     /**
-     * Update routing policy and persist to disk
+     * Update routing policy and persist via settings service
      */
     async updatePolicy(updates) {
         const currentPolicy = await this.getPolicy();
-        const newPolicy = {
-            defaultProvider: updates.defaultProvider || currentPolicy.defaultProvider,
-            operations: {
-                ...currentPolicy.operations,
-                ...updates.operations,
-            },
+        const mergedOperations = {
+            ...(currentPolicy.operations ?? {}),
+            ...(updates.operations ?? {}),
+        };
+        const operationsKeys = Object.keys(mergedOperations);
+        const nextPolicy = {
+            defaultProvider: updates.defaultProvider ?? currentPolicy.defaultProvider,
+            ...(operationsKeys.length > 0 ? { operations: mergedOperations } : {}),
         };
-        // Validate the new policy
-        const validated = RoutingPolicySchema.parse(newPolicy);
-        // Ensure .vibeman directory exists
-        const vibemanDir = path.dirname(this.policyFilePath);
-        await fs.mkdir(vibemanDir, { recursive: true });
-        // Write to file
-        await fs.writeFile(this.policyFilePath, JSON.stringify(validated, null, 2), 'utf-8');
-        // Update in-memory policy
+        const validated = RoutingPolicySchema.parse(nextPolicy);
+        await this.settingsService.updateSettings([
+            { path: ['agents', 'routingPolicy'], value: validated },
+        ]);
         this.policy = validated;
-        this.lastModified = Date.now();
         log.info('Updated AI routing policy', { policy: validated }, 'routing-policy');
     }
     /**
      * Resolve provider for a specific operation
      */
+    async getEffectivePolicy() {
+        const base = await this.getPolicy();
+        const operations = {
+            ...base.operations,
+        };
+        for (const op of ROUTABLE_OPERATIONS) {
+            if (!operations[op]) {
+                const resolved = await this.resolveProviderForOperation(op);
+                operations[op] = {
+                    provider: resolved.provider,
+                    ...(resolved.model ? { model: resolved.model } : {}),
+                    ...(resolved.options ? { options: resolved.options } : {}),
+                    ...(resolved.fallbacks && resolved.fallbacks.length
+                        ? { fallback: resolved.fallbacks }
+                        : {}),
+                };
+            }
+        }
+        return {
+            defaultProvider: base.defaultProvider,
+            operations,
+        };
+    }
     async resolveProviderForOperation(operation, overrides) {
         const policy = await this.getPolicy();
         const operationConfig = policy.operations?.[operation];
         // Pull provider/model defaults from settings per operation
-        const settings = getSettingsService().getSettings();
+        const settings = this.settingsService.getSettings();
         const coding = settings.agents?.codingAgent;
         const judge = settings.agents?.judgeAgent;
         const settingsProviderModel = (() => {
@@ -98,61 +121,54 @@ export class RoutingPolicyManager {
                 case 'ai_codereview':
                     return { provider: judge?.provider, model: judge?.model };
                 case 'execute_task':
-                case 'improve_task':
+                case 'quality_checks':
                 case 'ai_merge':
+                case 'improve_task':
                 default:
                     return { provider: coding?.provider, model: coding?.model };
             }
         })();
         // Start with operation-specific config or fall back to settings, then default policy
         const baseProvider = operationConfig?.provider || settingsProviderModel.provider || policy.defaultProvider;
-        const baseModel = operationConfig?.model || settingsProviderModel.model;
+        const baseModel = operationConfig?.model
+            ? operationConfig.model
+            : operationConfig?.provider
+                ? undefined
+                : settingsProviderModel.model;
         const baseOptions = operationConfig?.options;
         const baseFallbacks = operationConfig?.fallback || [];
         // Apply overrides
+        const overrideProviderOnly = overrides?.provider && overrides.model === undefined;
         const resolved = {
             provider: overrides?.provider || baseProvider,
-            model: overrides?.model || baseModel,
+            model: overrideProviderOnly ? undefined : overrides?.model || baseModel,
             options: overrides?.options || baseOptions,
             fallbacks: overrides?.fallbacks || baseFallbacks,
         };
         log.debug(`Resolved provider for ${operation}`, { operation, resolved }, 'routing-policy');
         return resolved;
     }
-    /**
-     * Set default provider
-     */
     async setDefaultProvider(provider) {
         await this.updatePolicy({ defaultProvider: provider });
     }
-    /**
-     * Set operation-specific routing
-     */
     async setOperationConfig(operation, config) {
         const currentPolicy = await this.getPolicy();
-        await this.updatePolicy({
-            operations: {
-                ...currentPolicy.operations,
-                [operation]: config,
-            },
-        });
+        const operations = {
+            ...(currentPolicy.operations ?? {}),
+            [operation]: config,
+        };
+        await this.updatePolicy({ operations });
     }
-    /**
-     * Validate policy against available providers
-     */
     validatePolicy(policy, availableProviders) {
         const errors = [];
-        // Check default provider
         if (!availableProviders.has(policy.defaultProvider)) {
             errors.push(`Default provider '${policy.defaultProvider}' is not available`);
         }
-        // Check operation providers
         if (policy.operations) {
             for (const [operation, config] of Object.entries(policy.operations)) {
                 if (!availableProviders.has(config.provider)) {
                     errors.push(`Provider '${config.provider}' for operation '${operation}' is not available`);
                 }
-                // Check fallback providers
                 if (config.fallback) {
                     for (const fallbackProvider of config.fallback) {
                         if (!availableProviders.has(fallbackProvider)) {
@@ -164,83 +180,17 @@ export class RoutingPolicyManager {
         }
         return errors;
     }
-    /**
-     * Load policy from file if it has changed
-     */
-    async loadPolicyIfChanged() {
-        try {
-            const stats = await fs.stat(this.policyFilePath);
-            const fileModified = stats.mtime.getTime();
-            // Only reload if file has changed
-            if (fileModified <= this.lastModified) {
-                return;
-            }
-            const content = await fs.readFile(this.policyFilePath, 'utf-8');
-            const parsed = JSON.parse(content);
-            const validated = RoutingPolicySchema.parse(parsed);
-            this.policy = validated;
-            this.lastModified = fileModified;
-            log.info('Loaded AI routing policy', { policy: validated }, 'routing-policy');
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                // File doesn't exist yet, use default
-                this.policy = null;
-                return;
-            }
-            log.warn('Failed to load routing policy, using defaults', error, 'routing-policy');
-            this.policy = null;
-        }
-    }
-    /**
-     * Create example policy file if it doesn't exist
-     */
-    async createExamplePolicy() {
-        const examplePath = path.join(getVibeDir(), 'ai-routing.example.json');
-        // Do not recreate if it already exists
-        try {
-            await fs.stat(examplePath);
-            return; // already exists; avoid noisy logs
-        }
-        catch (err) {
-            if (err?.code && err.code !== 'ENOENT') {
-                log.warn('Unable to stat example AI routing policy', err, 'routing-policy');
-                return;
-            }
-        }
-        const settings = getSettingsService().getSettings();
-        const example = {
-            defaultProvider: settings.agents.defaultProvider || 'claude-code',
-            operations: {
-                execute_task: {
-                    provider: settings.agents.defaultProvider || 'claude-code',
-                    model: 'claude-sonnet-4-20250514',
-                    fallback: ['codex'],
-                },
-                improve_task: {
-                    provider: settings.agents.defaultProvider || 'claude-code',
-                    model: 'claude-sonnet-4-20250514',
-                },
-                ai_codereview: {
-                    provider: 'codex',
-                    model: 'gpt-5',
-                },
-                ai_merge: {
-                    provider: settings.agents.defaultProvider || 'claude-code',
-                    model: 'claude-sonnet-4-20250514',
-                },
-            },
+    buildPolicyFromSettings() {
+        const settings = this.settingsService.getSettings();
+        const settingsPolicy = settings.agents?.routingPolicy;
+        const defaultProvider = settingsPolicy?.defaultProvider || settings.agents.defaultProvider || 'claude-code';
+        const operations = settingsPolicy?.operations
+            ? { ...settingsPolicy.operations }
+            : undefined;
+        const policy = {
+            defaultProvider,
+            ...(operations ? { operations } : {}),
         };
-        // Ensure .vibeman directory exists
-        const vibemanDir = path.dirname(examplePath);
-        await fs.mkdir(vibemanDir, { recursive: true });
-        await fs.writeFile(examplePath, JSON.stringify(example, null, 2), 'utf-8');
-        log.info('Created example AI routing policy', { path: examplePath }, 'routing-policy');
-    }
-    /**
-     * Get policy file path for external access
-     */
-    getPolicyFilePath() {
-        return this.policyFilePath;
+        return RoutingPolicySchema.parse(policy);
     }
 }

package/dist/runtime/api/agent/routing-policy.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import { RoutingPolicyManager, } from './routing-policy.js';
+import { getSettingsService } from '../settings-service.js';
+const settingsService = getSettingsService();
+const BASE_POLICY = {
+    defaultProvider: 'claude-code',
+    operations: {},
+};
+let originalRoutingPolicy;
+async function setRoutingPolicy(value) {
+    const result = await settingsService.updateSettings([
+        { path: ['agents', 'routingPolicy'], value },
+    ]);
+    if (!result.success) {
+        throw new Error(`Failed to set routing policy: ${JSON.stringify(result.errors)}`);
+    }
+}
+describe('RoutingPolicyManager resolve precedence', () => {
+    beforeAll(async () => {
+        await settingsService.initialize();
+        const manager = new RoutingPolicyManager();
+        originalRoutingPolicy = await manager.getPolicy();
+        await setRoutingPolicy(BASE_POLICY);
+    });
+    afterEach(async () => {
+        await setRoutingPolicy(BASE_POLICY);
+    });
+    afterAll(async () => {
+        await setRoutingPolicy(originalRoutingPolicy);
+    });
+    it('falls back to settings when no operation config or overrides', async () => {
+        const rpm = new RoutingPolicyManager();
+        const resolved = await rpm.resolveProviderForOperation('execute_task');
+        expect(resolved.provider).toBe('claude-code');
+        expect(resolved.model).toBe('claude-sonnet-4-20250514');
+    });
+    it('uses operation-specific policy when provided', async () => {
+        const rpm = new RoutingPolicyManager();
+        await rpm.updatePolicy({
+            operations: {
+                ai_merge: { provider: 'codex', model: 'gpt-5' },
+            },
+        });
+        const resolved = await rpm.resolveProviderForOperation('ai_merge');
+        expect(resolved.provider).toBe('codex');
+        expect(resolved.model).toBe('gpt-5');
+    });
+    it('when override sets provider without model, does not inherit mismatched model', async () => {
+        const rpm = new RoutingPolicyManager();
+        await rpm.updatePolicy({ operations: {} });
+        const override = { provider: 'codex' };
+        const resolved = await rpm.resolveProviderForOperation('execute_task', override);
+        expect(resolved.provider).toBe('codex');
+        expect(resolved.model).toBeUndefined();
+    });
+    it('override with provider+model takes full precedence', async () => {
+        const rpm = new RoutingPolicyManager();
+        const override = { provider: 'codex', model: 'gpt-5' };
+        const resolved = await rpm.resolveProviderForOperation('execute_task', override);
+        expect(resolved.provider).toBe('codex');
+        expect(resolved.model).toBe('gpt-5');
+    });
+});

package/dist/runtime/api/api/routers/ai.d.ts

@@ -40,7 +40,19 @@ export declare function buildAIRoutes(options: {
      */
     getRoutingPolicy: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
-        output: any;
+        output: {
+            defaultProvider: string;
+            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;
+                } | undefined;
+                model?: string | undefined;
+                fallback?: string[] | undefined;
+            }>> | undefined;
+        };
         meta: object;
     }>;
     /**
@@ -50,7 +62,7 @@ export declare function buildAIRoutes(options: {
         input: {
             policy: {
                 defaultProvider?: string | undefined;
-                operations?: Partial<Record<"execute_task" | "improve_task" | "ai_merge" | "ai_codereview", {
+                operations?: Partial<Record<"execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview", {
                     provider: string;
                     options?: {
                         temperature?: number | undefined;
@@ -86,7 +98,7 @@ export declare function buildAIRoutes(options: {
      */
     setOperationConfig: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            operation: "execute_task" | "improve_task" | "ai_merge" | "ai_codereview";
+            operation: "execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview";
             config: {
                 provider: string;
                 options?: {

package/dist/runtime/api/api/routers/ai.js

@@ -20,7 +20,7 @@ const SetDefaultProviderInputSchema = z.object({
     provider: z.string(),
 });
 const SetOperationConfigInputSchema = z.object({
-    operation: z.enum(['execute_task', 'improve_task', 'ai_codereview', 'ai_merge']),
+    operation: z.enum(['execute_task', 'quality_checks', 'ai_codereview', 'ai_merge', 'improve_task']),
     config: OperationConfigSchema,
 });
 const ValidateProvidersInputSchema = z.object({
@@ -92,16 +92,17 @@ export function buildAIRoutes(options) {
          */
         getRoutingPolicy: publicProcedure.query(async () => {
             try {
-                const policy = await agentService.getRoutingPolicyManager()?.getPolicy();
-                if (!policy) {
-                    // Return default policy if none exists
+                const rpm = agentService.getRoutingPolicyManager?.();
+                if (!rpm) {
                     const settings = getSettingsService().getSettings();
-                    const defaultPolicy = {
+                    return {
                         defaultProvider: settings.agents.defaultProvider || 'claude-code',
                         operations: {},
                     };
-                    return defaultPolicy;
                 }
+                const policy = (rpm.getEffectivePolicy
+                    ? await rpm.getEffectivePolicy()
+                    : await rpm.getPolicy());
                 log.debug('Retrieved routing policy', { policy }, 'ai-router');
                 return policy;
             }

package/dist/runtime/api/api/routers/executions.d.ts

@@ -67,7 +67,7 @@ export declare function buildExecutionRoutes({ taskService, vibingOrchestrator }
         input: {
             title: string;
             type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
-            priority: "high" | "medium" | "low";
+            priority: "low" | "medium" | "high";
             content: string;
             taskId: string;
             executionId?: string | undefined;

package/dist/runtime/api/api/routers/tasks.d.ts

@@ -6,7 +6,7 @@ export declare function buildTaskRoutes(taskService: TaskService, gitService?: G
             status?: "review" | "in-progress" | "backlog" | "done" | undefined;
             type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
             tags?: string[] | undefined;
-            priority?: "high" | "medium" | "low" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
             search?: string | undefined;
             includeDeleted?: boolean | undefined;
             onlyDeleted?: boolean | undefined;
@@ -31,7 +31,7 @@ export declare function buildTaskRoutes(taskService: TaskService, gitService?: G
             tags?: string[] | undefined;
             due_date?: string | undefined;
             assignee?: string[] | undefined;
-            priority?: "high" | "medium" | "low" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
             comments?: string[] | undefined;
         };
         output: import("../../types/index.js").Task;
@@ -46,7 +46,7 @@ export declare function buildTaskRoutes(taskService: TaskService, gitService?: G
             tags?: string[] | undefined;
             due_date?: string | undefined;
             assignee?: string[] | undefined;
-            priority?: "high" | "medium" | "low" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
             comments?: string[] | undefined;
             content?: string | undefined;
             deleted_at?: string | undefined;

package/dist/runtime/api/api/routers/workflows.d.ts

@@ -19,6 +19,10 @@ export declare function buildWorkflowRoutes({ vibingOrchestrator }: Deps): {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
+                    quality_checks?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
                     improve_task?: {
                         provider?: string | undefined;
                         model?: string | undefined;
@@ -55,6 +59,10 @@ export declare function buildWorkflowRoutes({ vibingOrchestrator }: Deps): {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
+                    quality_checks?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
                     improve_task?: {
                         provider?: string | undefined;
                         model?: string | undefined;

package/dist/runtime/api/api/routers/workflows.js

@@ -10,9 +10,10 @@ export function buildWorkflowRoutes({ vibingOrchestrator }) {
     const WorkflowAIRoutingOverrides = z
         .object({
         execute_task: OperationOverrideSchema.optional(),
-        improve_task: OperationOverrideSchema.optional(),
+        quality_checks: OperationOverrideSchema.optional(),
         ai_codereview: OperationOverrideSchema.optional(),
         ai_merge: OperationOverrideSchema.optional(),
+        improve_task: OperationOverrideSchema.optional(),
     })
         .partial();
     const WorkflowConfig = z.object({

package/dist/runtime/api/api/trpc.d.ts

@@ -36,7 +36,7 @@ export declare const TaskCreateSchema: z.ZodObject<{
     type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
     tags: string[];
     assignee: string[];
-    priority: "high" | "medium" | "low";
+    priority: "low" | "medium" | "high";
     comments: string[];
     content: string;
     id?: string | undefined;
@@ -50,7 +50,7 @@ export declare const TaskCreateSchema: z.ZodObject<{
     tags?: string[] | undefined;
     due_date?: string | undefined;
     assignee?: string[] | undefined;
-    priority?: "high" | "medium" | "low" | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
     comments?: string[] | undefined;
 }>;
 export declare const TaskUpdateSchema: z.ZodObject<{
@@ -74,7 +74,7 @@ export declare const TaskUpdateSchema: z.ZodObject<{
     tags?: string[] | undefined;
     due_date?: string | undefined;
     assignee?: string[] | undefined;
-    priority?: "high" | "medium" | "low" | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
     comments?: string[] | undefined;
     content?: string | undefined;
     deleted_at?: string | undefined;
@@ -86,7 +86,7 @@ export declare const TaskUpdateSchema: z.ZodObject<{
     tags?: string[] | undefined;
     due_date?: string | undefined;
     assignee?: string[] | undefined;
-    priority?: "high" | "medium" | "low" | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
     comments?: string[] | undefined;
     content?: string | undefined;
     deleted_at?: string | undefined;
@@ -103,7 +103,7 @@ export declare const TaskFilterSchema: z.ZodObject<{
     status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
     tags?: string[] | undefined;
-    priority?: "high" | "medium" | "low" | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
     search?: string | undefined;
     includeDeleted?: boolean | undefined;
     onlyDeleted?: boolean | undefined;
@@ -111,7 +111,7 @@ export declare const TaskFilterSchema: z.ZodObject<{
     status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
     tags?: string[] | undefined;
-    priority?: "high" | "medium" | "low" | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
     search?: string | undefined;
     includeDeleted?: boolean | undefined;
     onlyDeleted?: boolean | undefined;

package/dist/runtime/api/lib/trpc/server.d.ts

@@ -117,14 +117,26 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     getRoutingPolicy: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
-        output: any;
+        output: {
+            defaultProvider: string;
+            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;
+                } | undefined;
+                model?: string | undefined;
+                fallback?: string[] | undefined;
+            }>> | undefined;
+        };
         meta: object;
     }>;
     updateRoutingPolicy: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             policy: {
                 defaultProvider?: string | undefined;
-                operations?: Partial<Record<"execute_task" | "improve_task" | "ai_merge" | "ai_codereview", {
+                operations?: Partial<Record<"execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview", {
                     provider: string;
                     options?: {
                         temperature?: number | undefined;
@@ -154,7 +166,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
     }>;
     setOperationConfig: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            operation: "execute_task" | "improve_task" | "ai_merge" | "ai_codereview";
+            operation: "execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview";
             config: {
                 provider: string;
                 options?: {
@@ -347,6 +359,10 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
+                    quality_checks?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
                     improve_task?: {
                         provider?: string | undefined;
                         model?: string | undefined;
@@ -383,6 +399,10 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
+                    quality_checks?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
                     improve_task?: {
                         provider?: string | undefined;
                         model?: string | undefined;
@@ -747,7 +767,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
         input: {
             title: string;
             type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
-            priority: "high" | "medium" | "low";
+            priority: "low" | "medium" | "high";
             content: string;
             taskId: string;
             executionId?: string | undefined;
@@ -779,7 +799,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             status?: "review" | "in-progress" | "backlog" | "done" | undefined;
             type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
             tags?: string[] | undefined;
-            priority?: "high" | "medium" | "low" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
             search?: string | undefined;
             includeDeleted?: boolean | undefined;
             onlyDeleted?: boolean | undefined;
@@ -804,7 +824,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             tags?: string[] | undefined;
             due_date?: string | undefined;
             assignee?: string[] | undefined;
-            priority?: "high" | "medium" | "low" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
             comments?: string[] | undefined;
         };
         output: import("../../types/index.js").Task;
@@ -819,7 +839,7 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
             tags?: string[] | undefined;
             due_date?: string | undefined;
             assignee?: string[] | undefined;
-            priority?: "high" | "medium" | "low" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
             comments?: string[] | undefined;
             content?: string | undefined;
             deleted_at?: string | undefined;