vibeman 0.0.1 → 0.0.2

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;
-            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-            priority?: "low" | "medium" | "high" | undefined;
-            search?: string | undefined;
             tags?: string[] | undefined;
+            priority?: "high" | "medium" | "low" | undefined;
+            search?: 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: {
-            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
             title: string;
+            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
             content: string;
-            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-            priority?: "low" | "medium" | "high" | undefined;
+            status?: "review" | "in-progress" | "backlog" | "done" | 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;
-            type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-            status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-            priority?: "low" | "medium" | "high" | undefined;
+            status?: "review" | "in-progress" | "backlog" | "done" | undefined;
             title?: string | undefined;
+            type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | 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: "backlog" | "in-progress" | "review" | "done";
+            status: "review" | "in-progress" | "backlog" | "done";
             id: string;
         };
         output: import("../../types/index.js").Task;

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

@@ -1,19 +1,19 @@
 import type { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
 type Deps = {
-    requireOrchestrator: () => Promise<VibingOrchestrator>;
-    requireOrchestratorSync: () => VibingOrchestrator;
+    vibingOrchestrator: VibingOrchestrator;
 };
-export declare function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSync }: Deps): {
+export declare function buildWorkflowRoutes({ vibingOrchestrator }: Deps): {
     readonly updateWorkflowOptions: import("@trpc/server").TRPCMutationProcedure<{
         input: {
+            workflowId: string;
             config: {
+                autoCommit?: boolean | undefined;
+                createPR?: boolean | undefined;
                 autoQualityChecks?: boolean | undefined;
                 requireHumanApproval?: boolean | undefined;
-                aiCodeReview?: boolean | undefined;
-                autoCommit?: boolean | undefined;
                 stepByStepMode?: boolean | undefined;
-                createPR?: boolean | undefined;
                 autoMerge?: boolean | undefined;
+                aiCodeReview?: boolean | undefined;
                 aiRoutingOverrides?: {
                     execute_task?: {
                         provider?: string | undefined;
@@ -23,17 +23,16 @@ export declare function buildWorkflowRoutes({ requireOrchestrator, requireOrches
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
-                    ai_codereview?: {
+                    ai_merge?: {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
-                    ai_merge?: {
+                    ai_codereview?: {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
                 } | undefined;
             };
-            workflowId: string;
         };
         output: {
             readonly success: true;
@@ -44,13 +43,13 @@ export declare function buildWorkflowRoutes({ requireOrchestrator, requireOrches
         input: {
             taskId: string;
             config?: {
+                autoCommit?: boolean | undefined;
+                createPR?: boolean | undefined;
                 autoQualityChecks?: boolean | undefined;
                 requireHumanApproval?: boolean | undefined;
-                aiCodeReview?: boolean | undefined;
-                autoCommit?: boolean | undefined;
                 stepByStepMode?: boolean | undefined;
-                createPR?: boolean | undefined;
                 autoMerge?: boolean | undefined;
+                aiCodeReview?: boolean | undefined;
                 aiRoutingOverrides?: {
                     execute_task?: {
                         provider?: string | undefined;
@@ -60,11 +59,11 @@ export declare function buildWorkflowRoutes({ requireOrchestrator, requireOrches
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
-                    ai_codereview?: {
+                    ai_merge?: {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
-                    ai_merge?: {
+                    ai_codereview?: {
                         provider?: string | undefined;
                         model?: string | undefined;
                     } | undefined;
@@ -188,12 +187,12 @@ export declare function buildWorkflowRoutes({ requireOrchestrator, requireOrches
         output: import("../../types/index.js").VibingExecution | null;
         meta: object;
     }>;
-    readonly reviewCode: import("@trpc/server").TRPCMutationProcedure<{
+    readonly aiReviewCode: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             taskId: string;
             provider?: string | undefined;
-            model?: string | undefined;
             workflowId?: string | undefined;
+            model?: string | undefined;
             reviewContext?: string | undefined;
         };
         output: {

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

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { on, EventEmitter } from 'events';
 import { publicProcedure } from '../trpc.js';
 import { TRPCError } from '@trpc/server';
-export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSync }) {
+export function buildWorkflowRoutes({ vibingOrchestrator }) {
     const OperationOverrideSchema = z.object({
         provider: z.string().optional(),
         model: z.string().optional(),
@@ -30,14 +30,14 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         updateWorkflowOptions: publicProcedure
             .input(z.object({ workflowId: z.string(), config: WorkflowConfig }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.updateWorkflowOptions(input.workflowId, input.config);
             return { success: true };
         }),
         startWorkflow: publicProcedure
             .input(z.object({ taskId: z.string(), config: WorkflowConfigOpt }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             const workflowId = await orchestrator.startWorkflow(input.taskId, input.config || {});
             return { workflowId };
         }),
@@ -45,7 +45,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
             try {
-                const orchestrator = await requireOrchestrator();
+                const orchestrator = vibingOrchestrator;
                 await orchestrator.continueWorkflow(input.workflowId);
                 return { success: true };
             }
@@ -58,7 +58,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         runValidation: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.runValidation(input.workflowId);
             return { success: true };
         }),
@@ -69,7 +69,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             model: z.string().optional(),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.runMerge(input.workflowId, {
                 provider: input.provider,
                 model: input.model,
@@ -79,14 +79,14 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         runCleanup: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.runCleanup(input.workflowId);
             return { success: true };
         }),
         pauseWorkflow: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.pauseWorkflow(input.workflowId);
             return { success: true };
         }),
@@ -97,7 +97,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             force: z.boolean().optional(),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.resetWorkflow(input.workflowId, {
                 deleteWorktree: input.deleteWorktree,
                 force: input.force,
@@ -107,14 +107,14 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         approveWorkflow: publicProcedure
             .input(z.object({ workflowId: z.string(), comments: z.string().optional() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.approveWorkflow(input.workflowId);
             return { success: true };
         }),
         rejectWorkflow: publicProcedure
             .input(z.object({ workflowId: z.string(), feedback: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.rejectWorkflow(input.workflowId, input.feedback);
             return { success: true };
         }),
@@ -122,7 +122,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             .input(z.object({ taskId: z.string().optional() }).optional())
             .subscription(async function* (opts) {
             const input = opts.input;
-            const orchestrator = requireOrchestratorSync();
+            const orchestrator = vibingOrchestrator;
             const proxy = new EventEmitter();
             const handleStarted = (workflow) => {
                 if (!input?.taskId || workflow.taskId === input.taskId)
@@ -208,22 +208,22 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         getWorkflow: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .query(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return orchestrator.getWorkflow(input.workflowId);
         }),
         getWorkflowsByTaskId: publicProcedure
             .input(z.object({ taskId: z.string() }))
             .query(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return orchestrator.getTaskWorkflows(input.taskId);
         }),
         getLatestWorkflowByTaskId: publicProcedure
             .input(z.object({ taskId: z.string() }))
             .query(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return orchestrator.getLatestWorkflowByTask(input.taskId);
         }),
-        reviewCode: publicProcedure
+        aiReviewCode: publicProcedure
             .input(z.object({
             taskId: z.string(),
             workflowId: z.string().optional(),
@@ -232,31 +232,33 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             model: z.string().optional(),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
-            return await orchestrator.reviewCode(input.taskId, input.reviewContext, {
+            const orchestrator = vibingOrchestrator;
+            const overrides = input.provider || input.model
+                ? { provider: input.provider, model: input.model }
+                : undefined;
+            return await orchestrator.aiReviewCode(input.taskId, input.reviewContext, {
                 workflowId: input.workflowId,
-                provider: input.provider,
-                model: input.model,
+                overrides,
             });
         }),
         approveAndContinueReview: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.approveAndContinueReview(input.workflowId);
             return { success: true };
         }),
         markCompleted: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.markWorkflowCompleted(input.workflowId);
             return { success: true };
         }),
         checkWorktreeStatus: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return await orchestrator.checkWorktreeStatus(input.workflowId);
         }),
         rerunImplementation: publicProcedure
@@ -267,7 +269,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             model: z.string().optional(),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.rerunImplementation(input.workflowId, input.feedback, {
                 provider: input.provider,
                 model: input.model,
@@ -277,7 +279,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         skipToNextPhase: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.skipToNextPhase(input.workflowId);
             return { success: true };
         }),
@@ -300,7 +302,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             ]),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.rerunPhase(input.workflowId, input.phase);
             return { success: true };
         }),

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

@@ -1,9 +1,8 @@
 import type { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
 type Deps = {
-    requireOrchestrator: () => Promise<VibingOrchestrator>;
-    requireOrchestratorSync: () => VibingOrchestrator;
+    vibingOrchestrator: VibingOrchestrator;
 };
-export declare function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSync }: Deps): {
+export declare function buildWorktreeRoutes({ vibingOrchestrator }: Deps): {
     readonly listWorktrees: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
         output: (import("../../types/index.js").WorktreeInfo & {
@@ -88,9 +87,9 @@ export declare function buildWorktreeRoutes({ requireOrchestrator, requireOrches
     readonly cleanupWorktree: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             isConnectedToTask: boolean;
-            worktreePath?: string | undefined;
-            force?: boolean | undefined;
             taskId?: string | undefined;
+            force?: boolean | undefined;
+            worktreePath?: string | undefined;
             branchName?: string | undefined;
         };
         output: {

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

@@ -2,19 +2,19 @@ import { z } from 'zod';
 import { publicProcedure } from '../trpc.js';
 import { TaskIdSchema, WorktreePathSchema, withErrors } from '../router-helpers.js';
 import { log } from '../../lib/logger.js';
-export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSync }) {
+export function buildWorktreeRoutes({ vibingOrchestrator }) {
     return {
         listWorktrees: publicProcedure.query(withErrors('list worktrees', 'router:listWorktrees', async () => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return await orchestrator.listWorktrees();
         })),
         syncWorktreeState: publicProcedure.mutation(withErrors('sync worktree state', 'router:syncWorktreeState', async () => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.syncWorktreeState();
             return { success: true, message: 'Worktree state synchronized' };
         })),
         getWorktreeInfo: publicProcedure.input(TaskIdSchema).query(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             const worktree = orchestrator.getWorktreeInfo(input.taskId);
             if (!worktree)
                 return null;
@@ -22,7 +22,7 @@ export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSy
             return serializableWorktree;
         }),
         createWorktree: publicProcedure.input(TaskIdSchema).mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             const worktree = await orchestrator.createWorktree(input.taskId);
             const { git, ...serializableWorktree } = worktree;
             return serializableWorktree;
@@ -30,7 +30,7 @@ export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSy
         deleteWorktree: publicProcedure
             .input(z.object({ taskId: z.string(), force: z.coerce.boolean().optional() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.deleteWorktree(input.taskId, input.force || false);
             if (orchestrator) {
                 await orchestrator.removeWorkflowsByTask(input.taskId);
@@ -38,13 +38,13 @@ export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSy
             return { success: true };
         }),
         openInEditor: publicProcedure.input(WorktreePathSchema).mutation(withErrors('open in editor', 'router:openInEditor', async ({ input }) => {
-            const orchestrator = requireOrchestratorSync();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.openInEditor(input.worktreePath);
             // Ensure we return a clean, serializable object
             return { success: true };
         })),
         openInTerminal: publicProcedure.input(WorktreePathSchema).mutation(withErrors('open in terminal', 'router:openInTerminal', async ({ input }) => {
-            const orchestrator = requireOrchestratorSync();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.openInTerminal(input.worktreePath);
             // Ensure we return a clean, serializable object
             return { success: true };
@@ -53,14 +53,14 @@ export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSy
         createWorktreePR: publicProcedure
             .input(z.object({ taskId: z.string(), baseBranch: z.string().optional().default('main') }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             log.warn('Deprecated route used: createWorktreePR; prefer createPullRequest', { taskId: input.taskId }, 'router:createWorktreePR');
             return await orchestrator.createPullRequest(input.taskId, input.baseBranch);
         }),
         createPullRequest: publicProcedure
             .input(z.object({ taskId: z.string(), baseBranch: z.string().optional().default('main') }))
             .mutation(withErrors('create pull request', 'router:createPullRequest', async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return await orchestrator.createPullRequest(input.taskId, input.baseBranch);
         })),
         cleanupWorktree: publicProcedure
@@ -72,7 +72,7 @@ export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSy
             force: z.coerce.boolean().optional().default(false),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.cleanupWorktree(input);
             return { success: true };
         }),

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

@@ -31,26 +31,26 @@ export declare const TaskCreateSchema: z.ZodObject<{
     comments: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     content: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
-    status: "backlog" | "in-progress" | "review" | "done";
-    priority: "low" | "medium" | "high";
+    status: "review" | "in-progress" | "backlog" | "done";
     title: string;
+    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
     tags: string[];
     assignee: string[];
+    priority: "high" | "medium" | "low";
     comments: string[];
     content: string;
     id?: string | undefined;
     due_date?: string | undefined;
 }, {
-    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
     title: string;
+    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
     content: string;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     id?: string | undefined;
     tags?: string[] | undefined;
     due_date?: string | undefined;
     assignee?: string[] | undefined;
+    priority?: "high" | "medium" | "low" | undefined;
     comments?: string[] | undefined;
 }>;
 export declare const TaskUpdateSchema: z.ZodObject<{
@@ -68,25 +68,25 @@ export declare const TaskUpdateSchema: z.ZodObject<{
     deleted_at: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     id: string;
-    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     title?: string | undefined;
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | 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;
 }, {
     id: string;
-    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     title?: string | undefined;
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | 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;
@@ -100,19 +100,19 @@ export declare const TaskFilterSchema: z.ZodObject<{
     includeDeleted: z.ZodOptional<z.ZodBoolean>;
     onlyDeleted: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
-    search?: string | undefined;
     tags?: string[] | undefined;
+    priority?: "high" | "medium" | "low" | undefined;
+    search?: string | undefined;
     includeDeleted?: boolean | undefined;
     onlyDeleted?: boolean | undefined;
 }, {
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
-    search?: string | undefined;
     tags?: string[] | undefined;
+    priority?: "high" | "medium" | "low" | undefined;
+    search?: string | undefined;
     includeDeleted?: boolean | undefined;
     onlyDeleted?: boolean | undefined;
 }>;

package/dist/runtime/api/index.js

@@ -100,16 +100,8 @@ try {
     if (isMain) {
         const host = process.env.HOST || 'localhost';
         const resolveApiPort = async () => {
-            // Highest precedence: explicit API port
-            const explicit = getNumberEnv('VIBEMAN_API_PORT', NaN);
-            if (Number.isFinite(explicit) && explicit > 0)
-                return explicit;
-            // If PORT (web) is set, use web+1
-            const webPort = getNumberEnv('PORT', 0);
-            if (webPort > 0)
-                return webPort + 1;
-            // Default dev behavior: assume web on 3000, so API on 3001
-            return 3001;
+            const port = getNumberEnv('PORT', 3000);
+            return port + 1;
         };
         (async () => {
             const port = await resolveApiPort();