vibeman 0.0.2 → 0.0.5

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.1-codex' },
+            },
+        });
+        const resolved = await rpm.resolveProviderForOperation('ai_merge');
+        expect(resolved.provider).toBe('codex');
+        expect(resolved.model).toBe('gpt-5.1-codex');
+    });
+    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.1-codex' };
+        const resolved = await rpm.resolveProviderForOperation('execute_task', override);
+        expect(resolved.provider).toBe('codex');
+        expect(resolved.model).toBe('gpt-5.1-codex');
+    });
+});

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" | "ai_codereview" | "ai_merge" | "improve_task", {
+                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" | "ai_codereview" | "ai_merge" | "improve_task", {
                     provider: string;
                     options?: {
                         temperature?: number | undefined;
@@ -86,7 +98,6 @@ export declare function buildAIRoutes(options: {
      */
     setOperationConfig: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            operation: "execute_task" | "improve_task" | "ai_merge" | "ai_codereview";
             config: {
                 provider: string;
                 options?: {
@@ -97,6 +108,7 @@ export declare function buildAIRoutes(options: {
                 model?: string | undefined;
                 fallback?: string[] | undefined;
             };
+            operation: "execute_task" | "quality_checks" | "ai_codereview" | "ai_merge" | "improve_task";
         };
         output: {
             success: boolean;

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

@@ -65,20 +65,15 @@ export declare function buildExecutionRoutes({ taskService, vibingOrchestrator }
     }>;
     readonly improveTask: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            title: string;
             type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
-            priority: "high" | "medium" | "low";
+            priority: "low" | "medium" | "high";
+            title: string;
             content: string;
             taskId: string;
             executionId?: string | undefined;
         };
         output: {
-            type: string;
-            priority: string;
-            content: string;
-            title?: string;
-            executionId: string;
-            selectedModel?: string;
+            readonly executionId: string;
         };
         meta: object;
     }>;

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

@@ -53,13 +53,13 @@ export function buildExecutionRoutes({ taskService, vibingOrchestrator }) {
         }))
             .mutation(async ({ input }) => {
             assertTaskActive(input.taskId);
-            const improvement = await vibingOrchestrator.improveTaskContent(input.taskId, {
+            const { executionId } = await vibingOrchestrator.startTaskImprovement(input.taskId, {
                 title: input.title,
                 type: input.type,
                 priority: input.priority,
                 content: input.content,
             }, { executionId: input.executionId });
-            return improvement;
+            return { executionId };
         }),
         onExecutionUpdate: publicProcedure
             .input(z.object({ executionId: z.string() }))

package/dist/runtime/api/api/routers/provider-config.d.ts

@@ -69,6 +69,18 @@ export declare function buildProviderConfigRoutes(): {
                     lastDetected?: string | undefined;
                     detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
                 } | undefined;
+                gemini?: {
+                    binPath?: string | undefined;
+                    detectedPath?: string | undefined;
+                    lastDetected?: string | undefined;
+                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+                } | undefined;
+                amp?: {
+                    binPath?: string | undefined;
+                    detectedPath?: string | undefined;
+                    lastDetected?: string | undefined;
+                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+                } | undefined;
             };
             path: string;
             exists: boolean;
@@ -107,6 +119,16 @@ export declare function buildProviderConfigRoutes(): {
                     detectedPath?: string | undefined;
                     lastDetected?: string | undefined;
                     detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+                } | {
+                    binPath?: string | undefined;
+                    detectedPath?: string | undefined;
+                    lastDetected?: string | undefined;
+                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+                } | {
+                    binPath?: string | undefined;
+                    detectedPath?: string | undefined;
+                    lastDetected?: string | undefined;
+                    detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
                 } | undefined;
                 cached: {
                     available: boolean;
@@ -154,6 +176,18 @@ export declare function buildProviderConfigRouteHandlers(): {
                 lastDetected?: string | undefined;
                 detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
             } | undefined;
+            gemini?: {
+                binPath?: string | undefined;
+                detectedPath?: string | undefined;
+                lastDetected?: string | undefined;
+                detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+            } | undefined;
+            amp?: {
+                binPath?: string | undefined;
+                detectedPath?: string | undefined;
+                lastDetected?: string | undefined;
+                detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+            } | undefined;
         };
         path: string;
         exists: boolean;

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

@@ -2,6 +2,25 @@
  * tRPC routes for settings management
  */
 export declare function buildSettingsRoutes(): {
+    /**
+     * Get current project information
+     */
+    getProjectInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            name: string;
+            path: string;
+        };
+        meta: object;
+    }>;
+    /**
+     * Get Vibeman application information
+     */
+    getVibemanInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: import("../../lib/server/vibeman-info.js").VibemanInfo;
+        meta: object;
+    }>;
     /**
      * Get current settings
      */

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

@@ -1,11 +1,13 @@
 /**
  * tRPC routes for settings management
  */
+import path from 'path';
 import { z } from 'zod';
 import { publicProcedure } from '../trpc.js';
 import { getSettingsService } from '../../settings-service.js';
 import { QualityPipeline } from '../../workflows/quality-pipeline.js';
 import { getProjectRoot } from '../../lib/server/project-root.js';
+import { getVibemanInfo } from '../../lib/server/vibeman-info.js';
 // Input validation schemas
 const UpdateSettingsInputSchema = z.array(z.object({
     path: z.array(z.string().min(1)),
@@ -16,6 +18,20 @@ export function buildSettingsRoutes() {
     // Initialize settings service on first router build
     settingsService.initialize().catch(console.error);
     return {
+        /**
+         * Get current project information
+         */
+        getProjectInfo: publicProcedure.query(async () => {
+            const root = getProjectRoot();
+            const name = path.basename(root);
+            return { name, path: root };
+        }),
+        /**
+         * Get Vibeman application information
+         */
+        getVibemanInfo: publicProcedure.query(async () => {
+            return getVibemanInfo();
+        }),
         /**
          * Get current settings
          */

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

@@ -3,11 +3,11 @@ import type { GitService } from '../../vcs/git-service.js';
 export declare function buildTaskRoutes(taskService: TaskService, gitService?: GitService): {
     readonly listTasks: import("@trpc/server").TRPCQueryProcedure<{
         input: {
-            status?: "review" | "in-progress" | "backlog" | "done" | undefined;
             type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-            tags?: string[] | undefined;
-            priority?: "high" | "medium" | "low" | undefined;
+            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
             search?: string | undefined;
+            tags?: string[] | undefined;
             includeDeleted?: boolean | undefined;
             onlyDeleted?: boolean | undefined;
         } | undefined;
@@ -23,15 +23,15 @@ export declare function buildTaskRoutes(taskService: TaskService, gitService?: G
     }>;
     readonly createTask: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            title: string;
             type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
+            title: string;
             content: string;
-            status?: "review" | "in-progress" | "backlog" | "done" | undefined;
+            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
             id?: string | undefined;
             tags?: string[] | undefined;
             due_date?: string | undefined;
             assignee?: string[] | undefined;
-            priority?: "high" | "medium" | "low" | undefined;
             comments?: string[] | undefined;
         };
         output: import("../../types/index.js").Task;
@@ -40,13 +40,13 @@ export declare function buildTaskRoutes(taskService: TaskService, gitService?: G
     readonly updateTask: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             id: string;
-            status?: "review" | "in-progress" | "backlog" | "done" | undefined;
-            title?: string | undefined;
             type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+            priority?: "low" | "medium" | "high" | undefined;
+            title?: string | undefined;
             tags?: string[] | undefined;
             due_date?: string | undefined;
             assignee?: string[] | undefined;
-            priority?: "high" | "medium" | "low" | undefined;
             comments?: string[] | undefined;
             content?: string | undefined;
             deleted_at?: string | undefined;
@@ -65,7 +65,7 @@ export declare function buildTaskRoutes(taskService: TaskService, gitService?: G
     }>;
     readonly moveTask: import("@trpc/server").TRPCMutationProcedure<{
         input: {
-            status: "review" | "in-progress" | "backlog" | "done";
+            status: "backlog" | "in-progress" | "review" | "done";
             id: string;
         };
         output: import("../../types/index.js").Task;